@valescoagency/runway 0.7.0 → 0.8.0

package/dist/dashboard/storage.js

@@ -0,0 +1,304 @@
+import { DatabaseSync } from "node:sqlite";
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS drains (
+    trace_id TEXT NOT NULL,
+    span_id TEXT NOT NULL,
+    start_time_unix_nano TEXT NOT NULL,
+    end_time_unix_nano TEXT NOT NULL,
+    attempts INTEGER,
+    opened INTEGER,
+    hitl INTEGER,
+    errored INTEGER,
+    status_code INTEGER,
+    status_message TEXT,
+    inserted_at TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (trace_id, span_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS issue_processes (
+    trace_id TEXT NOT NULL,
+    span_id TEXT NOT NULL,
+    parent_span_id TEXT,
+    issue_identifier TEXT NOT NULL,
+    issue_id TEXT,
+    branch TEXT,
+    outcome_kind TEXT,
+    outcome_detail TEXT,
+    start_time_unix_nano TEXT NOT NULL,
+    end_time_unix_nano TEXT NOT NULL,
+    status_code INTEGER,
+    status_message TEXT,
+    inserted_at TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (trace_id, span_id)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_issue_processes_inserted_at
+    ON issue_processes(inserted_at DESC);
+
+  CREATE INDEX IF NOT EXISTS idx_issue_processes_trace_id
+    ON issue_processes(trace_id);
+
+  CREATE TABLE IF NOT EXISTS raw_spans (
+    trace_id TEXT NOT NULL,
+    span_id TEXT NOT NULL,
+    name TEXT NOT NULL,
+    payload TEXT NOT NULL,
+    inserted_at TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (trace_id, span_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS agent_iterations (
+    trace_id TEXT NOT NULL,
+    id TEXT NOT NULL,
+    issue_process_id TEXT,
+    iteration_index INTEGER NOT NULL,
+    started_at TEXT NOT NULL,
+    ended_at TEXT NOT NULL,
+    sandcastle_run_id TEXT,
+    exit_status TEXT,
+    inserted_at TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (trace_id, id)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_agent_iterations_issue_process
+    ON agent_iterations(trace_id, issue_process_id, iteration_index);
+`;
+/**
+ * Open (or create) a SQLite database at `path` and return a typed
+ * `Storage` handle. Pass `:memory:` for tests — the in-memory db
+ * lives for the lifetime of the returned handle.
+ *
+ * INSERTs use `ON CONFLICT ... DO UPDATE` so retried emits (e.g. the
+ * OTel SDK retrying a flush) don't blow up the receiver — last writer
+ * wins on (trace_id, span_id).
+ */
+export function createStorage(path) {
+    const db = new DatabaseSync(path);
+    db.exec(SCHEMA);
+    const insertDrain = db.prepare(`
+    INSERT INTO drains (
+      trace_id, span_id, start_time_unix_nano, end_time_unix_nano,
+      attempts, opened, hitl, errored, status_code, status_message
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT (trace_id, span_id) DO UPDATE SET
+      start_time_unix_nano = excluded.start_time_unix_nano,
+      end_time_unix_nano = excluded.end_time_unix_nano,
+      attempts = excluded.attempts,
+      opened = excluded.opened,
+      hitl = excluded.hitl,
+      errored = excluded.errored,
+      status_code = excluded.status_code,
+      status_message = excluded.status_message
+  `);
+    const insertIssueProcess = db.prepare(`
+    INSERT INTO issue_processes (
+      trace_id, span_id, parent_span_id, issue_identifier, issue_id,
+      branch, outcome_kind, outcome_detail,
+      start_time_unix_nano, end_time_unix_nano, status_code, status_message
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT (trace_id, span_id) DO UPDATE SET
+      parent_span_id = excluded.parent_span_id,
+      issue_identifier = excluded.issue_identifier,
+      issue_id = excluded.issue_id,
+      branch = excluded.branch,
+      outcome_kind = excluded.outcome_kind,
+      outcome_detail = excluded.outcome_detail,
+      start_time_unix_nano = excluded.start_time_unix_nano,
+      end_time_unix_nano = excluded.end_time_unix_nano,
+      status_code = excluded.status_code,
+      status_message = excluded.status_message
+  `);
+    const insertRawSpan = db.prepare(`
+    INSERT INTO raw_spans (trace_id, span_id, name, payload)
+    VALUES (?, ?, ?, ?)
+    ON CONFLICT (trace_id, span_id) DO UPDATE SET
+      name = excluded.name,
+      payload = excluded.payload
+  `);
+    const insertAgentIteration = db.prepare(`
+    INSERT INTO agent_iterations (
+      trace_id, id, issue_process_id, iteration_index,
+      started_at, ended_at, sandcastle_run_id, exit_status
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT (trace_id, id) DO UPDATE SET
+      issue_process_id = excluded.issue_process_id,
+      iteration_index = excluded.iteration_index,
+      started_at = excluded.started_at,
+      ended_at = excluded.ended_at,
+      sandcastle_run_id = excluded.sandcastle_run_id,
+      exit_status = excluded.exit_status
+  `);
+    // Two list variants instead of one with conditional SQL — keeps
+    // each prepared statement static.
+    const listAll = db.prepare(`
+    SELECT
+      trace_id, span_id, parent_span_id, issue_identifier, issue_id,
+      branch, outcome_kind, outcome_detail,
+      start_time_unix_nano, end_time_unix_nano, status_code, status_message,
+      inserted_at
+    FROM issue_processes
+    ORDER BY inserted_at DESC, span_id DESC
+    LIMIT ?
+  `);
+    const listByTrace = db.prepare(`
+    SELECT
+      trace_id, span_id, parent_span_id, issue_identifier, issue_id,
+      branch, outcome_kind, outcome_detail,
+      start_time_unix_nano, end_time_unix_nano, status_code, status_message,
+      inserted_at
+    FROM issue_processes
+    WHERE trace_id = ?
+    ORDER BY inserted_at DESC, span_id DESC
+    LIMIT ?
+  `);
+    const getProcessStmt = db.prepare(`
+    SELECT
+      trace_id, span_id, parent_span_id, issue_identifier, issue_id,
+      branch, outcome_kind, outcome_detail,
+      start_time_unix_nano, end_time_unix_nano, status_code, status_message,
+      inserted_at
+    FROM issue_processes
+    WHERE trace_id = ? AND span_id = ?
+  `);
+    const listIterations = db.prepare(`
+    SELECT
+      trace_id, id, issue_process_id, iteration_index,
+      started_at, ended_at, sandcastle_run_id, exit_status,
+      inserted_at
+    FROM agent_iterations
+    WHERE trace_id = ? AND issue_process_id = ?
+    ORDER BY iteration_index ASC
+  `);
+    const saveDrain = (d) => {
+        insertDrain.run(d.traceId, d.spanId, d.startTimeUnixNano, d.endTimeUnixNano, asInt(d.attempts), asInt(d.opened), asInt(d.hitl), asInt(d.errored), asInt(d.statusCode), d.statusMessage);
+    };
+    const saveIssueProcess = (p) => {
+        insertIssueProcess.run(p.traceId, p.spanId, p.parentSpanId, p.issueIdentifier, p.issueId, p.branch, p.outcomeKind, p.outcomeDetail, p.startTimeUnixNano, p.endTimeUnixNano, asInt(p.statusCode), p.statusMessage);
+    };
+    const saveAgentIteration = (a) => {
+        insertAgentIteration.run(a.traceId, a.spanId, a.issueProcessSpanId, asInt(a.iterationIndex), a.startTimeUnixNano, a.endTimeUnixNano, a.sandcastleRunId, a.exitStatus);
+    };
+    const saveRawSpan = (r) => {
+        insertRawSpan.run(r.traceId, r.spanId, r.name, r.payload);
+    };
+    const listIssueProcesses = (filter) => {
+        const limit = filter?.limit ?? 100;
+        const rows = filter?.traceId
+            ? listByTrace.all(filter.traceId, limit)
+            : listAll.all(limit);
+        return rows.map(rowToIssueProcess);
+    };
+    const getIssueProcess = (traceId, spanId) => {
+        const row = getProcessStmt.get(traceId, spanId);
+        return row ? rowToIssueProcess(row) : undefined;
+    };
+    const listAgentIterations = (traceId, issueProcessSpanId) => {
+        const rows = listIterations.all(traceId, issueProcessSpanId);
+        return rows.map(rowToAgentIteration);
+    };
+    /**
+     * VA-389: phase spans (review, pushBranch, openPullRequest) live in
+     * `raw_spans` as JSON. SQLite's `json_extract` lets us pull
+     * parentSpanId + start/end without re-projecting the payload at
+     * insert time. The names allowlist becomes a comma-bind so each
+     * call is one prepared statement; we don't precompute a fixed
+     * statement because the allowlist could grow per slice.
+     */
+    const listPhaseSpans = (traceId, issueProcessSpanId, names) => {
+        if (names.length === 0)
+            return [];
+        const placeholders = names.map(() => "?").join(", ");
+        const sql = `
+      SELECT
+        trace_id,
+        span_id,
+        name,
+        json_extract(payload, '$.parentSpanId') AS parent_span_id,
+        json_extract(payload, '$.startTimeUnixNano') AS start_time_unix_nano,
+        json_extract(payload, '$.endTimeUnixNano') AS end_time_unix_nano
+      FROM raw_spans
+      WHERE trace_id = ?
+        AND json_extract(payload, '$.parentSpanId') = ?
+        AND name IN (${placeholders})
+      ORDER BY start_time_unix_nano ASC
+    `;
+        const rows = db
+            .prepare(sql)
+            .all(traceId, issueProcessSpanId, ...names);
+        return rows.map(rowToPhaseSpan);
+    };
+    const close = () => {
+        db.close();
+    };
+    return {
+        saveDrain,
+        saveIssueProcess,
+        saveAgentIteration,
+        saveRawSpan,
+        listIssueProcesses,
+        getIssueProcess,
+        listAgentIterations,
+        listPhaseSpans,
+        close,
+    };
+}
+// node:sqlite's bind types are TEXT/INTEGER/BLOB/REAL/null. `undefined`
+// throws; coerce to `null` so an "unset counter" column round-trips
+// cleanly.
+function asInt(n) {
+    return n === null || n === undefined ? null : n;
+}
+function rowToIssueProcess(row) {
+    const r = row;
+    return {
+        traceId: String(r.trace_id ?? ""),
+        spanId: String(r.span_id ?? ""),
+        parentSpanId: nullableStr(r.parent_span_id),
+        issueIdentifier: String(r.issue_identifier ?? ""),
+        issueId: nullableStr(r.issue_id),
+        branch: nullableStr(r.branch),
+        outcomeKind: nullableStr(r.outcome_kind),
+        outcomeDetail: nullableStr(r.outcome_detail),
+        startTimeUnixNano: String(r.start_time_unix_nano ?? ""),
+        endTimeUnixNano: String(r.end_time_unix_nano ?? ""),
+        statusCode: nullableNum(r.status_code),
+        statusMessage: nullableStr(r.status_message),
+        insertedAt: String(r.inserted_at ?? ""),
+    };
+}
+function rowToAgentIteration(row) {
+    const r = row;
+    return {
+        traceId: String(r.trace_id ?? ""),
+        spanId: String(r.id ?? ""),
+        issueProcessSpanId: nullableStr(r.issue_process_id),
+        iterationIndex: Number(r.iteration_index ?? 0),
+        startTimeUnixNano: String(r.started_at ?? ""),
+        endTimeUnixNano: String(r.ended_at ?? ""),
+        sandcastleRunId: nullableStr(r.sandcastle_run_id),
+        exitStatus: nullableStr(r.exit_status),
+        insertedAt: String(r.inserted_at ?? ""),
+    };
+}
+function rowToPhaseSpan(row) {
+    const r = row;
+    return {
+        traceId: String(r.trace_id ?? ""),
+        spanId: String(r.span_id ?? ""),
+        parentSpanId: nullableStr(r.parent_span_id),
+        name: String(r.name ?? ""),
+        startTimeUnixNano: String(r.start_time_unix_nano ?? ""),
+        endTimeUnixNano: String(r.end_time_unix_nano ?? ""),
+    };
+}
+function nullableStr(v) {
+    if (v === null || v === undefined)
+        return null;
+    return String(v);
+}
+function nullableNum(v) {
+    if (v === null || v === undefined)
+        return null;
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+}

package/dist/dashboard/views.js

@@ -0,0 +1,288 @@
+/**
+ * VA-386: minimal SSR HTML for the dashboard list view. No framework,
+ * no client JS — slice 1 just needs one row per issue process with
+ * its identifier and outcome (per AC). VA-389 adds the per-issue
+ * detail pane (phase timeline + agent iterations).
+ *
+ * `escapeHtml` is the only XSS guard between SQLite and the rendered
+ * page — every dynamic field passes through it.
+ */
+const SHARED_STYLE = `
+    body { font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, monospace;
+           background: #0e0e10; color: #e5e5e5; margin: 0; padding: 24px; }
+    a { color: #93c5fd; text-decoration: none; }
+    a:hover { text-decoration: underline; }
+    h1 { font-size: 16px; font-weight: 600; margin: 0 0 16px; }
+    h2 { font-size: 13px; font-weight: 500; color: #9ca3af;
+         margin: 24px 0 8px; text-transform: uppercase; letter-spacing: 0.05em; }
+    table { border-collapse: collapse; width: 100%; font-size: 13px; }
+    th, td { text-align: left; padding: 8px 12px; border-bottom: 1px solid #2a2a2e; }
+    th { color: #9ca3af; font-weight: 500; }
+    .outcome { font-weight: 600; }
+    .outcome-opened { color: #4ade80; }
+    .outcome-hitl { color: #facc15; }
+    .outcome-reverted { color: #fb923c; }
+    .outcome-errored { color: #f87171; }
+    .outcome-pending { color: #9ca3af; }
+    .empty { color: #9ca3af; padding: 24px; text-align: center; }
+    .id { color: #93c5fd; }
+    .detail { color: #d4d4d8; }
+    .muted { color: #9ca3af; }
+    code { background: #1f2937; padding: 1px 6px; border-radius: 3px; }
+`;
+export function renderListView(rows) {
+    const tableBody = rows.length === 0
+        ? `<tr><td colspan="4" class="empty">No issue processes yet. Run <code>runway run</code> with <code>OTEL_EXPORTER_OTLP_ENDPOINT</code> pointing here to populate.</td></tr>`
+        : rows.map(renderRow).join("");
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>runway dashboard</title>
+  <style>${SHARED_STYLE}</style>
+</head>
+<body>
+  <h1>runway · issue processes</h1>
+  <table>
+    <thead>
+      <tr>
+        <th>Issue</th>
+        <th>Outcome</th>
+        <th>Detail</th>
+        <th>Seen at</th>
+      </tr>
+    </thead>
+    <tbody>${tableBody}</tbody>
+  </table>
+</body>
+</html>`;
+}
+function renderRow(r) {
+    const kind = r.outcomeKind ?? "pending";
+    const outcomeCls = `outcome outcome-${escapeHtml(kind)}`;
+    const href = `/issue/${encodeURIComponent(r.traceId)}/${encodeURIComponent(r.spanId)}`;
+    return `<tr>
+    <td class="id"><a href="${escapeHtml(href)}">${escapeHtml(r.issueIdentifier)}</a></td>
+    <td class="${outcomeCls}">${escapeHtml(kind)}</td>
+    <td class="detail">${escapeHtml(r.outcomeDetail ?? "")}</td>
+    <td>${escapeHtml(r.insertedAt)}</td>
+  </tr>`;
+}
+const FINALIZE_PHASE_NAMES = ["pushBranch", "openPullRequest"];
+/**
+ * VA-389: render the per-issue detail page. The phase timeline is the
+ * core of the page — it shows implement / review / finalize as a
+ * horizontal bar with durations and per-iteration expansion for
+ * implement. Phases without timing data (e.g. a HITL run that never
+ * reached finalize) are silently skipped.
+ */
+export function renderDetailView(vm) {
+    const phases = computePhases(vm);
+    const phaseTimeline = renderPhaseTimeline(phases);
+    const phaseTable = renderPhaseTable(phases, vm.iterations);
+    const ip = vm.issueProcess;
+    const kind = ip.outcomeKind ?? "pending";
+    const outcomeCls = `outcome outcome-${escapeHtml(kind)}`;
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>${escapeHtml(ip.issueIdentifier)} · runway dashboard</title>
+  <style>${SHARED_STYLE}
+    .breadcrumb { color: #9ca3af; margin-bottom: 16px; font-size: 12px; }
+    .meta { margin: 4px 0 16px; }
+    .meta .label { color: #9ca3af; margin-right: 4px; }
+    .timeline { position: relative; height: 28px; background: #18181b;
+                border-radius: 4px; margin: 12px 0 4px; overflow: hidden; }
+    .timeline .phase { position: absolute; top: 0; bottom: 0;
+                       display: flex; align-items: center; padding: 0 8px;
+                       font-size: 11px; color: #0e0e10; font-weight: 600;
+                       white-space: nowrap; overflow: hidden; }
+    .timeline .phase-implement { background: #60a5fa; }
+    .timeline .phase-review    { background: #facc15; }
+    .timeline .phase-finalize  { background: #4ade80; }
+    .timeline-legend { font-size: 11px; color: #9ca3af; margin-bottom: 16px; }
+    .iter-row td { background: #16161a; padding-left: 32px; }
+    .iter-status { font-weight: 600; }
+    .iter-status-done     { color: #4ade80; }
+    .iter-status-blocked  { color: #f87171; }
+    .iter-status-continue { color: #facc15; }
+    .iter-status-missing  { color: #9ca3af; }
+  </style>
+</head>
+<body>
+  <div class="breadcrumb"><a href="/">← all issue processes</a></div>
+  <h1>${escapeHtml(ip.issueIdentifier)} · <span class="${outcomeCls}">${escapeHtml(kind)}</span></h1>
+  <div class="meta">
+    <div><span class="label">branch:</span><code>${escapeHtml(ip.branch ?? "—")}</code></div>
+    <div><span class="label">detail:</span><span class="detail">${escapeHtml(ip.outcomeDetail ?? "")}</span></div>
+    <div><span class="label">seen at:</span>${escapeHtml(ip.insertedAt)}</div>
+  </div>
+
+  <h2>Phase timeline</h2>
+  ${phaseTimeline}
+  ${phaseTable}
+</body>
+</html>`;
+}
+/**
+ * Assemble the three phase rows from the typed iteration table
+ * (implement) and the raw_spans phase lookup (review, finalize).
+ * Returns the phases that actually have timing data — a hitl issue
+ * that never reached review still renders cleanly.
+ */
+function computePhases(vm) {
+    const phases = [];
+    if (vm.iterations.length > 0) {
+        const startNs = minBigInt(vm.iterations.map((i) => parseNs(i.startTimeUnixNano)));
+        const endNs = maxBigInt(vm.iterations.map((i) => parseNs(i.endTimeUnixNano)));
+        phases.push({ name: "implement", startNs, endNs });
+    }
+    const review = vm.phaseSpans.find((p) => p.name === "review");
+    if (review) {
+        phases.push({
+            name: "review",
+            startNs: parseNs(review.startTimeUnixNano),
+            endNs: parseNs(review.endTimeUnixNano),
+        });
+    }
+    const finalize = vm.phaseSpans.filter((p) => FINALIZE_PHASE_NAMES.includes(p.name));
+    if (finalize.length > 0) {
+        const startNs = minBigInt(finalize.map((p) => parseNs(p.startTimeUnixNano)));
+        const endNs = maxBigInt(finalize.map((p) => parseNs(p.endTimeUnixNano)));
+        phases.push({ name: "finalize", startNs, endNs });
+    }
+    return phases;
+}
+function renderPhaseTimeline(phases) {
+    if (phases.length === 0) {
+        return `<div class="empty">No phase spans recorded yet.</div>`;
+    }
+    const totalStart = minBigInt(phases.map((p) => p.startNs));
+    const totalEnd = maxBigInt(phases.map((p) => p.endNs));
+    const totalSpanNs = totalEnd - totalStart;
+    // Guard against a single-point timeline (all phases collapsed).
+    // Render each phase at fixed width so the bar still appears.
+    const denom = totalSpanNs === 0n ? 1n : totalSpanNs;
+    const bars = phases
+        .map((p) => {
+        const leftPct = pct(p.startNs - totalStart, denom);
+        const widthPct = pct(p.endNs - p.startNs, denom);
+        const safeWidth = widthPct < 1 ? 1 : widthPct;
+        return `<div class="phase phase-${p.name}" style="left:${leftPct}%;width:${safeWidth}%">${p.name} · ${escapeHtml(formatDuration(p.endNs - p.startNs))}</div>`;
+    })
+        .join("");
+    return `
+  <div class="timeline">${bars}</div>
+  <div class="timeline-legend">${escapeHtml(formatTimestamp(totalStart))} → ${escapeHtml(formatTimestamp(totalEnd))} (total ${escapeHtml(formatDuration(totalSpanNs))})</div>`;
+}
+function renderPhaseTable(phases, iterations) {
+    if (phases.length === 0) {
+        return "";
+    }
+    const rows = phases
+        .map((p) => {
+        const dur = formatDuration(p.endNs - p.startNs);
+        const start = formatTimestamp(p.startNs);
+        const end = formatTimestamp(p.endNs);
+        const head = `<tr>
+      <td>${escapeHtml(p.name)}</td>
+      <td>${escapeHtml(start)}</td>
+      <td>${escapeHtml(end)}</td>
+      <td>${escapeHtml(dur)}</td>
+    </tr>`;
+        if (p.name === "implement") {
+            return head + iterations.map(renderIterationRow).join("");
+        }
+        return head;
+    })
+        .join("");
+    return `<table>
+    <thead>
+      <tr>
+        <th>Phase</th>
+        <th>Start</th>
+        <th>End</th>
+        <th>Duration</th>
+      </tr>
+    </thead>
+    <tbody>${rows}</tbody>
+  </table>`;
+}
+function renderIterationRow(it) {
+    const status = it.exitStatus ?? "missing";
+    const statusCls = `iter-status iter-status-${escapeHtml(status)}`;
+    const dur = formatDuration(parseNs(it.endTimeUnixNano) - parseNs(it.startTimeUnixNano));
+    return `<tr class="iter-row">
+    <td class="muted">↳ iter ${it.iterationIndex}</td>
+    <td colspan="2"><span class="${statusCls}">${escapeHtml(status)}</span></td>
+    <td>${escapeHtml(dur)}</td>
+  </tr>`;
+}
+/**
+ * Parse an OTLP int64 unix-nanos string into a BigInt. The OTLP wire
+ * keeps these as strings so we don't lose precision through `number`;
+ * the dashboard never displays sub-microsecond detail so we drop back
+ * to `Number` only at format time.
+ */
+function parseNs(ns) {
+    if (!ns)
+        return 0n;
+    try {
+        return BigInt(ns);
+    }
+    catch {
+        return 0n;
+    }
+}
+function minBigInt(xs) {
+    let m = xs[0] ?? 0n;
+    for (const x of xs)
+        if (x < m)
+            m = x;
+    return m;
+}
+function maxBigInt(xs) {
+    let m = xs[0] ?? 0n;
+    for (const x of xs)
+        if (x > m)
+            m = x;
+    return m;
+}
+function pct(num, denom) {
+    if (denom === 0n)
+        return 0;
+    // Multiply by 10000 in BigInt land first, then drop to Number — keeps
+    // sub-percent precision on long traces without overflowing.
+    const scaled = Number((num * 10000n) / denom);
+    return scaled / 100;
+}
+function formatDuration(ns) {
+    if (ns <= 0n)
+        return "0ms";
+    const ms = Number(ns / 1000000n);
+    if (ms < 1000)
+        return `${ms}ms`;
+    const s = ms / 1000;
+    if (s < 60)
+        return `${s.toFixed(2)}s`;
+    const m = Math.floor(s / 60);
+    const rem = s - m * 60;
+    return `${m}m${rem.toFixed(1)}s`;
+}
+function formatTimestamp(ns) {
+    if (ns <= 0n)
+        return "—";
+    const ms = Number(ns / 1000000n);
+    return new Date(ms).toISOString();
+}
+const ESC = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+};
+export function escapeHtml(input) {
+    return input.replace(/[&<>"']/g, (c) => ESC[c] ?? c);
+}

package/dist/finalize.js

@@ -20,7 +20,10 @@ export const finalize = (issue, deps, branch) => Effect.gen(function* () {
     yield* linear.comment(issue.id, `Runway opened a PR for review: ${prUrl}`);
     return { kind: "opened", detail: prUrl };
 });
-function buildPrBody(issue) {
+// VA-412: `Closes` (not `Refs`) is the Linear GitHub-integration magic
+// word that auto-transitions the issue to Done on PR merge. `Refs`
+// only attaches the PR to the issue and leaves it stuck In Progress.
+export function buildPrBody(issue) {
     return [
         `Runway-generated PR for **${issue.identifier} — ${issue.title}**.`,
         "",
@@ -30,6 +33,6 @@ function buildPrBody(issue) {
         "",
         issue.description || "(no description)",
         "",
-        `Refs ${issue.identifier}`,
+        `Closes ${issue.identifier}`,
     ].join("\n");
 }

package/dist/implement.js

@@ -61,15 +61,30 @@ export const runImplementLoop = (issue, deps, branch) => Effect.gen(function* ()
             // toward the same code paths until corrected.
             priorReviewFeedback: priorFeedback,
         }));
-        implementResult = yield* runSandcastle({
-            agent: claudeCode("claude-opus-4-7"),
-            sandbox: docker({ env: dockerEnv(config) }),
-            cwd,
-            prompt: implementPrompt,
-            branchStrategy: { type: "branch", branch },
-            maxIterations: 1,
-            completionSignal: [...IMPL_COMPLETION_SIGNALS],
-            name: `impl-${issue.identifier}-iter-${iter}`,
+        const sandcastleRunId = `impl-${issue.identifier}-iter-${iter}`;
+        // VA-389: parse the verdict inside the span scope so the
+        // dashboard projector can read `runway.iteration.exit_status`
+        // off the `impl-iter-N` span without joining against the agent
+        // log. `runway.iteration.sandcastle_run_id` lets a future link
+        // to the per-run output (raw stdout, etc.) without needing to
+        // rebuild the name from issue identifier + iteration.
+        implementResult = yield* Effect.gen(function* () {
+            const result = yield* runSandcastle({
+                agent: claudeCode("claude-opus-4-7"),
+                sandbox: docker({ env: dockerEnv(config) }),
+                cwd,
+                prompt: implementPrompt,
+                branchStrategy: { type: "branch", branch },
+                maxIterations: config.implTurns,
+                completionSignal: [...IMPL_COMPLETION_SIGNALS],
+                name: sandcastleRunId,
+            });
+            const verdict = parseImplVerdict(result);
+            yield* Effect.annotateCurrentSpan({
+                "runway.iteration.exit_status": verdict.kind,
+                "runway.iteration.sandcastle_run_id": sandcastleRunId,
+            });
+            return result;
         }).pipe(Effect.withSpan(`impl-iter-${iter}`, {
             attributes: {
                 "runway.iteration": iter,