@valescoagency/runway 0.7.1 → 0.8.0

package/README.md

@@ -392,7 +392,7 @@ These are tractable, just not v1.
 
 ## Status
 
-0.7.1 — production-shaped and dogfooded against live Linear queues.
+0.8.0 — production-shaped and dogfooded against live Linear queues.
 The end-to-end pipeline (init → run → review → PR) is stable; surface
 may still shift as the orchestrator's policy and iteration mechanics
 mature. See [CHANGELOG.md](./CHANGELOG.md) for per-release detail.

package/dist/commands/run.js

@@ -49,6 +49,25 @@ export function parseRunArgs(argv) {
         else if (a?.startsWith("--allow-paths=")) {
             collectAllow(a.slice("--allow-paths=".length));
         }
+        else if (a === "--impl-turns") {
+            const v = argv[i + 1];
+            if (!v)
+                throw new Error("--impl-turns requires a number");
+            const n = Number.parseInt(v, 10);
+            if (!Number.isFinite(n) || n <= 0) {
+                throw new Error(`--impl-turns must be a positive integer, got "${v}"`);
+            }
+            opts.implTurns = n;
+            i += 1;
+        }
+        else if (a?.startsWith("--impl-turns=")) {
+            const v = a.slice("--impl-turns=".length);
+            const n = Number.parseInt(v, 10);
+            if (!Number.isFinite(n) || n <= 0) {
+                throw new Error(`--impl-turns must be a positive integer, got "${v}"`);
+            }
+            opts.implTurns = n;
+        }
         else if (a === "--help" || a === "-h") {
             printRunUsage();
             process.exit(0);
@@ -79,6 +98,10 @@ OPTIONS
                   Example: --allow-paths='.github/workflows/**' lets
                   the agent touch CI for issues whose AC require it.
                   Repeatable; pairs with .runway/policy.yml.
+  --impl-turns N  Sandcastle inner turn budget for each impl phase
+                  (how many turns the Claude agent gets per attempt
+                  before it has to signal IMPL: DONE / BLOCKED).
+                  Overrides RUNWAY_IMPL_TURNS. Default: 3.
   --help, -h      Show this help.
 
 ENVIRONMENT
@@ -93,7 +116,12 @@ ENVIRONMENT
   RUNWAY_IN_PROGRESS_STATUS   default "In Progress"
   RUNWAY_IN_REVIEW_STATUS     default "In Review"
   RUNWAY_HITL_LABEL           default "ready-for-human"
-  RUNWAY_MAX_ITERATIONS       default 5
+  RUNWAY_MAX_ITERATIONS       default 5  — outer impl re-prompt loop
+                              (only fires when the agent fails to
+                              signal IMPL: DONE / BLOCKED at all)
+  RUNWAY_IMPL_TURNS           default 3  — sandcastle inner turn
+                              budget per impl phase. Overridden by
+                              --impl-turns.
 `);
 }
 export async function runCommand(argv) {
@@ -120,9 +148,11 @@ export async function runCommand(argv) {
     const MainLayer = Layer.mergeAll(ConfigLive, TelemetryLive, LoggerLive);
     const program = Effect.gen(function* () {
         const baseConfig = yield* ConfigTag;
-        const config = opts.project
-            ? { ...baseConfig, linearProject: opts.project }
-            : baseConfig;
+        const config = {
+            ...baseConfig,
+            ...(opts.project ? { linearProject: opts.project } : {}),
+            ...(opts.implTurns !== undefined ? { implTurns: opts.implTurns } : {}),
+        };
         const scope = config.linearProject
             ? `team ${config.linearTeam} / project ${config.linearProject}`
             : `team ${config.linearTeam}`;

package/dist/config.js

@@ -1,4 +1,4 @@
-import { Config as EConfig, Context, Effect, Layer, Option, } from "effect";
+import { Config as EConfig, ConfigProvider, Context, Effect, Layer, Option, } from "effect";
 /**
  * VA-359: Effect.Config program that reads every var from
  * `process.env`, applies defaults, and yields a typed `RunwayConfig`.
@@ -20,6 +20,10 @@ const configEffect = EConfig.all({
         message: "RUNWAY_MAX_ITERATIONS must be a positive integer",
         validation: (n) => n > 0,
     })),
+    implTurns: EConfig.integer("RUNWAY_IMPL_TURNS").pipe(EConfig.withDefault(3), EConfig.validate({
+        message: "RUNWAY_IMPL_TURNS must be a positive integer",
+        validation: (n) => n > 0,
+    })),
     commentAuthorAllowlist: EConfig.option(EConfig.string("RUNWAY_COMMENT_AUTHOR_ALLOWLIST")),
 }).pipe(Effect.map((raw) => ({
     linearApiKey: raw.linearApiKey,
@@ -32,6 +36,7 @@ const configEffect = EConfig.all({
     inReviewStatus: raw.inReviewStatus,
     hitlLabel: raw.hitlLabel,
     maxIterations: raw.maxIterations,
+    implTurns: raw.implTurns,
     commentAuthorAllowlist: Option.getOrUndefined(raw.commentAuthorAllowlist)
         ?.split(",")
         .map((s) => s.trim())
@@ -44,11 +49,35 @@ const configEffect = EConfig.all({
  */
 export class ConfigTag extends Context.Tag("RunwayConfig")() {
 }
+// VA-411: Build a ConfigProvider from an explicit env-like object so
+// tests (and any other caller that needs hermetic isolation from the
+// host environment) can drive config loading without mutating
+// `process.env`. The path delimiter matches Effect's `fromEnv` so a
+// `Map(process.env)` and a real env behave the same for our flat
+// `RUNWAY_*` keys.
+const providerFromEnv = (env) => {
+    const map = new Map();
+    for (const [k, v] of Object.entries(env)) {
+        if (typeof v === "string")
+            map.set(k, v);
+    }
+    return ConfigProvider.fromMap(map, { pathDelim: "_" });
+};
+/**
+ * VA-411: Build a `ConfigLive` Layer that resolves env vars from an
+ * explicit env map instead of `process.env`. Production callers use
+ * the default `ConfigLive` (which reads `process.env`); tests pass
+ * an explicit map so host env leaks (e.g. an `.envrc` that exports
+ * `RUNWAY_LINEAR_PROJECT`) can't break assertions.
+ */
+export function makeConfigLive(env = process.env) {
+    return Layer.effect(ConfigTag, configEffect.pipe(Effect.withConfigProvider(providerFromEnv(env))));
+}
 /**
  * Layer that resolves env vars once and makes the result available
  * via `ConfigTag` for the rest of the program.
  */
-export const ConfigLive = Layer.effect(ConfigTag, configEffect);
+export const ConfigLive = makeConfigLive();
 /**
  * Sync helper for non-Effect callers (`runway doctor` early
  * validation, the `runway run` CLI bootstrap before it enters
@@ -56,7 +85,11 @@ export const ConfigLive = Layer.effect(ConfigTag, configEffect);
  * the `ConfigError` on a missing/invalid env var — the caller's
  * existing `catch (err) { … errMsg(err) … }` shape rendered the
  * Zod issue the same way it'll now render the Effect ConfigError.
+ *
+ * VA-411: Accepts an optional `env` map so tests can drive the
+ * loader hermetically. Defaults to `process.env` for production
+ * callers.
  */
-export function loadConfig() {
-    return Effect.runSync(configEffect);
+export function loadConfig(env = process.env) {
+    return Effect.runSync(configEffect.pipe(Effect.withConfigProvider(providerFromEnv(env))));
 }

package/dist/dashboard/otlp.js

@@ -0,0 +1,55 @@
+/**
+ * OTLP HTTP/JSON wire types — just enough of the
+ * `opentelemetry.proto.trace.v1` shape to project runway's spans. The
+ * full proto schema is much larger; we model only the fields we read.
+ *
+ * Reference: https://opentelemetry.io/docs/specs/otlp/#otlphttp-request
+ * The JSON encoding for int64 fields (timestamps, intValue) is
+ * `string` per the proto3 JSON mapping — we keep them as strings so
+ * we never lose precision through `number`.
+ */
+/**
+ * Coerce an OTLP attribute value to a plain JS scalar. We collapse
+ * the typed wire variants (`stringValue` / `intValue` / `boolValue` /
+ * `doubleValue`) into one return path so callers downstream can
+ * pattern-match without knowing the OTLP shape.
+ *
+ * `intValue` round-trips as a string to preserve int64 precision.
+ * Callers that want a `number` (e.g. for counters under 2^53) should
+ * `Number(...)` it themselves.
+ */
+export function attrValue(attr) {
+    if (!attr)
+        return undefined;
+    const v = attr.value;
+    if (v.stringValue !== undefined)
+        return v.stringValue;
+    if (v.boolValue !== undefined)
+        return v.boolValue;
+    if (v.doubleValue !== undefined)
+        return v.doubleValue;
+    if (v.intValue !== undefined) {
+        // OTLP int64 — JSON form is string per proto3, but the SDK
+        // sometimes emits as number for small ints. Accept both.
+        return typeof v.intValue === "string"
+            ? v.intValue
+            : v.intValue;
+    }
+    return undefined;
+}
+/**
+ * Build a key → scalar map from an OTLP attribute list. Unknown
+ * variants drop silently — projector code shouldn't crash on a span
+ * with an attribute shape we haven't enumerated.
+ */
+export function attrMap(attrs) {
+    const out = {};
+    if (!attrs)
+        return out;
+    for (const a of attrs) {
+        const v = attrValue(a);
+        if (v !== undefined)
+            out[a.key] = v;
+    }
+    return out;
+}

package/dist/dashboard/projector.js

@@ -0,0 +1,127 @@
+import { attrMap, } from "./otlp.js";
+const DRAIN_SPAN = "drainQueue";
+const ISSUE_PROCESS_SPAN = "processIssue";
+const IMPL_ITER_SPAN_RE = /^impl-iter-(\d+)$/;
+/**
+ * Project an OTLP traces payload into typed runway rows + the raw
+ * escape hatch. Every span (typed or not) lands in `raw_spans`; the
+ * domain spans additionally project into their typed tables.
+ */
+export function projectPayload(payload) {
+    const drains = [];
+    const issueProcesses = [];
+    const agentIterations = [];
+    const rawSpans = [];
+    for (const rs of payload.resourceSpans ?? []) {
+        collectFromResourceSpan(rs, drains, issueProcesses, agentIterations, rawSpans);
+    }
+    return { drains, issueProcesses, agentIterations, rawSpans };
+}
+function collectFromResourceSpan(rs, drains, issueProcesses, agentIterations, rawSpans) {
+    for (const ss of rs.scopeSpans ?? []) {
+        for (const span of ss.spans ?? []) {
+            rawSpans.push(projectRawSpan(span));
+            if (span.name === DRAIN_SPAN) {
+                drains.push(projectDrain(span));
+            }
+            else if (span.name === ISSUE_PROCESS_SPAN) {
+                const ip = projectIssueProcess(span);
+                if (ip)
+                    issueProcesses.push(ip);
+            }
+            else {
+                const iter = projectAgentIteration(span);
+                if (iter)
+                    agentIterations.push(iter);
+            }
+        }
+    }
+}
+function projectRawSpan(span) {
+    return {
+        traceId: span.traceId,
+        spanId: span.spanId,
+        name: span.name,
+        payload: JSON.stringify(span),
+    };
+}
+function projectDrain(span) {
+    const m = attrMap(span.attributes);
+    return {
+        traceId: span.traceId,
+        spanId: span.spanId,
+        startTimeUnixNano: span.startTimeUnixNano,
+        endTimeUnixNano: span.endTimeUnixNano,
+        attempts: numAttr(m["runway.drain.attempts"]),
+        opened: numAttr(m["runway.drain.opened"]),
+        hitl: numAttr(m["runway.drain.hitl"]),
+        errored: numAttr(m["runway.drain.errored"]),
+        statusCode: span.status?.code ?? null,
+        statusMessage: span.status?.message ?? null,
+    };
+}
+/**
+ * `processIssue` rows are keyed on `runway.issue.identifier`. A span
+ * named `processIssue` without that attribute is dropped from the
+ * typed table (it still lands in `raw_spans`) — without a stable
+ * identifier we have nothing to render on the row, and a silently
+ * blank row is more confusing than no row.
+ */
+function projectIssueProcess(span) {
+    const m = attrMap(span.attributes);
+    const identifier = strAttr(m["runway.issue.identifier"]);
+    if (!identifier)
+        return undefined;
+    return {
+        traceId: span.traceId,
+        spanId: span.spanId,
+        parentSpanId: span.parentSpanId ?? null,
+        issueIdentifier: identifier,
+        issueId: strAttr(m["runway.issue.id"]) ?? null,
+        branch: strAttr(m["runway.branch"]) ?? null,
+        outcomeKind: strAttr(m["runway.outcome.kind"]) ?? null,
+        outcomeDetail: strAttr(m["runway.outcome.detail"]) ?? null,
+        startTimeUnixNano: span.startTimeUnixNano,
+        endTimeUnixNano: span.endTimeUnixNano,
+        statusCode: span.status?.code ?? null,
+        statusMessage: span.status?.message ?? null,
+    };
+}
+/**
+ * VA-389: project a span named `impl-iter-N` into an `AgentIteration`
+ * row. Iteration index comes from the span name (the canonical
+ * classifier); `runway.iteration.exit_status` and
+ * `runway.iteration.sandcastle_run_id` (annotated by the implement
+ * loop) carry the per-iteration metadata the detail pane shows.
+ */
+function projectAgentIteration(span) {
+    const match = IMPL_ITER_SPAN_RE.exec(span.name);
+    if (!match)
+        return undefined;
+    const idx = Number(match[1]);
+    if (!Number.isFinite(idx))
+        return undefined;
+    const m = attrMap(span.attributes);
+    return {
+        traceId: span.traceId,
+        spanId: span.spanId,
+        issueProcessSpanId: span.parentSpanId ?? null,
+        iterationIndex: idx,
+        startTimeUnixNano: span.startTimeUnixNano,
+        endTimeUnixNano: span.endTimeUnixNano,
+        sandcastleRunId: strAttr(m["runway.iteration.sandcastle_run_id"]) ?? null,
+        exitStatus: strAttr(m["runway.iteration.exit_status"]) ?? null,
+    };
+}
+function strAttr(v) {
+    return typeof v === "string" ? v : undefined;
+}
+function numAttr(v) {
+    if (typeof v === "number")
+        return v;
+    if (typeof v === "string") {
+        const n = Number(v);
+        return Number.isFinite(n) ? n : null;
+    }
+    return null;
+}

package/dist/dashboard/server.js

@@ -0,0 +1,233 @@
+import { createServer } from "node:http";
+import { projectPayload } from "./projector.js";
+import { createStorage } from "./storage.js";
+import { renderDetailView, renderListView } from "./views.js";
+// VA-389: phase spans we surface on the detail page's timeline.
+// Anything else stays in raw_spans for debugging but isn't rendered.
+const DETAIL_PHASE_NAMES = ["review", "pushBranch", "openPullRequest"];
+const ISSUE_DETAIL_RE = /^\/issue\/([^/?#]+)\/([^/?#]+)\/?$/;
+const MAX_BODY_BYTES = 10 * 1024 * 1024; // 10 MiB — generous; a runway drain is ~kilobytes per emit.
+/**
+ * Construct a Node HTTP server wired to the given storage. The server
+ * is NOT listening yet — call `.listen()` on the returned `server` or
+ * use `startServer` for the all-in-one helper.
+ */
+export function buildServer(storage) {
+    return createServer((req, res) => {
+        handle(req, res, storage).catch((err) => {
+            writeError(res, 500, "internal_error", asMessage(err));
+        });
+    });
+}
+/**
+ * Bind and start the dashboard server. Returns a handle the caller can
+ * use to close it gracefully (used by tests).
+ */
+export async function startServer(opts) {
+    const server = buildServer(opts.storage);
+    const port = opts.port ?? 4318;
+    const host = opts.host ?? "0.0.0.0";
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const addr = server.address();
+    const boundPort = addr && typeof addr === "object" ? addr.port : port;
+    return {
+        server,
+        port: boundPort,
+        close: () => new Promise((resolve, reject) => {
+            server.close((err) => (err ? reject(err) : resolve()));
+        }),
+    };
+}
+async function handle(req, res, storage) {
+    // Route on method + path. Nothing fancy — slice 1 only has two
+    // endpoints; a router becomes worth its weight in slice 2.
+    const url = req.url ?? "/";
+    const method = req.method ?? "GET";
+    if (method === "POST" && url === "/v1/traces") {
+        await handleOtlpTraces(req, res, storage);
+        return;
+    }
+    if (method === "GET" && (url === "/" || url.startsWith("/?"))) {
+        handleListView(res, storage);
+        return;
+    }
+    if (method === "GET") {
+        const detailMatch = ISSUE_DETAIL_RE.exec(url.split("?")[0] ?? "");
+        if (detailMatch) {
+            const traceId = decodeURIComponent(detailMatch[1] ?? "");
+            const spanId = decodeURIComponent(detailMatch[2] ?? "");
+            handleDetailView(res, storage, traceId, spanId);
+            return;
+        }
+    }
+    if (method === "GET" && url === "/healthz") {
+        res.writeHead(200, { "content-type": "text/plain" });
+        res.end("ok");
+        return;
+    }
+    writeError(res, 404, "not_found", `no route for ${method} ${url}`);
+}
+/**
+ * Read the request body, parse as OTLP HTTP/JSON, project, and
+ * persist. Responds with the OTLP success shape (`{ partialSuccess:
+ * {} }`) per spec so the SDK exporter doesn't retry.
+ *
+ * We only accept JSON. The OTLP HTTP/protobuf variant would need a
+ * proto parser in this hot path; the runway exporter
+ * (`@opentelemetry/exporter-trace-otlp-http`) emits JSON by default,
+ * which is the only encoding slice 1 is on the hook for.
+ */
+async function handleOtlpTraces(req, res, storage) {
+    const ct = (req.headers["content-type"] ?? "").toString().toLowerCase();
+    if (!ct.includes("application/json")) {
+        writeError(res, 415, "unsupported_media_type", `expected application/json, got "${ct}"`);
+        return;
+    }
+    const body = await readBody(req);
+    if (body === undefined) {
+        writeError(res, 413, "payload_too_large", `body exceeds ${MAX_BODY_BYTES} bytes`);
+        return;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(body);
+    }
+    catch (err) {
+        writeError(res, 400, "invalid_json", asMessage(err));
+        return;
+    }
+    const projection = projectPayload(payload);
+    for (const d of projection.drains)
+        storage.saveDrain(d);
+    for (const p of projection.issueProcesses)
+        storage.saveIssueProcess(p);
+    for (const a of projection.agentIterations)
+        storage.saveAgentIteration(a);
+    for (const r of projection.rawSpans)
+        storage.saveRawSpan(r);
+    // OTLP success body: a small JSON envelope. Required by the spec
+    // even on a "we accepted everything" path so SDKs don't treat the
+    // empty body as a partial failure.
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify({ partialSuccess: {} }));
+}
+function handleListView(res, storage) {
+    const rows = storage.listIssueProcesses({ limit: 100 });
+    const html = renderListView(rows);
+    res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+    res.end(html);
+}
+/**
+ * VA-389: per-issue detail page. Composes the issue_process row,
+ * iteration list, and review/finalize phase spans into a single view
+ * model and hands it to `renderDetailView`. Returns 404 when the
+ * (trace_id, span_id) pair doesn't match a known issue process — the
+ * dashboard never auto-creates rows from a URL.
+ */
+function handleDetailView(res, storage, traceId, spanId) {
+    const ip = storage.getIssueProcess(traceId, spanId);
+    if (!ip) {
+        writeError(res, 404, "not_found", `no issue process for trace=${traceId} span=${spanId}`);
+        return;
+    }
+    const iterations = storage.listAgentIterations(traceId, spanId);
+    const phaseSpans = storage.listPhaseSpans(traceId, spanId, [
+        ...DETAIL_PHASE_NAMES,
+    ]);
+    const html = renderDetailView({
+        issueProcess: ip,
+        iterations,
+        phaseSpans,
+    });
+    res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+    res.end(html);
+}
+async function readBody(req) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buf = chunk instanceof Buffer ? chunk : Buffer.from(chunk);
+        total += buf.length;
+        if (total > MAX_BODY_BYTES)
+            return undefined;
+        chunks.push(buf);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function writeError(res, status, code, message) {
+    res.writeHead(status, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: { code, message } }));
+}
+function asMessage(err) {
+    if (err && typeof err === "object" && "message" in err) {
+        const m = err.message;
+        if (typeof m === "string")
+            return m;
+    }
+    return String(err);
+}
+/**
+ * Default entry point invoked by the docker container. Resolves
+ * `SQLITE_PATH`, `OTLP_PORT`, and `DASHBOARD_PORT` from env, opens
+ * storage, and binds two listeners against the same handler — the
+ * OTLP receiver and the dashboard UI both speak the same set of
+ * routes; the dual ports are conventional, not enforced. Exits the
+ * process on a SIGINT/SIGTERM after closing the DB.
+ */
+export async function main() {
+    const sqlitePath = process.env.SQLITE_PATH ?? "/data/runway.sqlite";
+    const otlpPort = parsePort("OTLP_PORT", "4318");
+    const dashboardPort = parsePort("DASHBOARD_PORT", "3001");
+    const storage = createStorage(sqlitePath);
+    const otlp = await startServer({ storage, port: otlpPort });
+    const dashboard = dashboardPort === otlpPort
+        ? otlp
+        : await startServer({ storage, port: dashboardPort });
+    console.log(`[runway dashboard] OTLP :${otlp.port} · dashboard :${dashboard.port}; sqlite=${sqlitePath}`);
+    const shutdown = async (signal) => {
+        console.log(`[runway dashboard] ${signal} — shutting down`);
+        await otlp.close();
+        if (dashboard !== otlp)
+            await dashboard.close();
+        storage.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", () => void shutdown("SIGINT"));
+    process.on("SIGTERM", () => void shutdown("SIGTERM"));
+}
+function parsePort(envName, fallback) {
+    const raw = process.env[envName] ?? fallback;
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new Error(`invalid ${envName}: "${raw}"`);
+    }
+    return n;
+}
+// Run as a script when executed directly (e.g. inside the Docker
+// container's CMD). Skipped when imported by tests.
+const isMain = (() => {
+    try {
+        const argv1 = process.argv[1];
+        if (!argv1)
+            return false;
+        // Match either the compiled `dist/dashboard/server.js` or the
+        // tsx-source `src/dashboard/server.ts`, so both `runway dash` and
+        // `tsx src/dashboard/server.ts` work.
+        return /[/\\]dashboard[/\\]server\.(js|ts)$/.test(argv1);
+    }
+    catch {
+        return false;
+    }
+})();
+if (isMain) {
+    main().catch((err) => {
+        console.error("[runway dashboard] fatal:", asMessage(err));
+        process.exit(1);
+    });
+}

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,

package/dist/orchestrator.js

@@ -100,7 +100,32 @@ export const drainQueue = (deps, opts = {}) => Effect.gen(function* () {
         seen.add(issue.id);
         attempts += 1;
         const branch = `agent/${issue.identifier.toLowerCase()}`;
-        const processed = yield* processIssue(issue, runDeps).pipe(Effect.either, Effect.withSpan("processIssue", {
+        // VA-386: the dashboard projector reads the final outcome from
+        // the processIssue span's attributes. Compute it inside the
+        // span scope (so `annotateCurrentSpan` targets `processIssue`,
+        // not `drainQueue`) and route afterwards.
+        const resolved = yield* Effect.gen(function* () {
+            const processed = yield* processIssue(issue, runDeps).pipe(Effect.either);
+            if (processed._tag === "Right") {
+                const result = processed.right;
+                yield* Effect.annotateCurrentSpan({
+                    "runway.outcome.kind": result.kind,
+                    "runway.outcome.detail": result.detail,
+                });
+                return { errored: false, outcome: result };
+            }
+            const failureOutcome = yield* handleProcessFailure(processed.left, issue, runDeps, branch);
+            yield* Effect.annotateCurrentSpan({
+                "runway.outcome.kind": failureOutcome.kind,
+                "runway.outcome.detail": failureOutcome.detail,
+                // True when the issue process exited via the failure path
+                // — distinguishes "planned HITL" (kind=hitl, errored=false)
+                // from "crashed and routed to HITL" (kind=hitl,
+                // errored=true) on the dashboard row.
+                "runway.outcome.errored": true,
+            });
+            return { errored: true, outcome: failureOutcome };
+        }).pipe(Effect.withSpan("processIssue", {
             attributes: {
                 "runway.issue.identifier": issue.identifier,
                 "runway.issue.id": issue.id,
@@ -110,29 +135,30 @@ export const drainQueue = (deps, opts = {}) => Effect.gen(function* () {
             issue: issue.identifier,
             branch,
         }));
-        if (processed._tag === "Right") {
-            const result = processed.right;
-            if (result.kind === "opened")
-                opened += 1;
-            if (result.kind === "hitl")
-                hitl += 1;
-            outcomes.push({
-                identifier: issue.identifier,
-                kind: result.kind,
-                detail: result.detail,
-            });
+        if (resolved.errored) {
+            errored += 1;
         }
         else {
-            errored += 1;
-            const failureOutcome = yield* handleProcessFailure(processed.left, issue, runDeps, branch);
-            outcomes.push({
-                identifier: issue.identifier,
-                kind: failureOutcome.kind,
-                detail: failureOutcome.detail,
-            });
+            if (resolved.outcome.kind === "opened")
+                opened += 1;
+            if (resolved.outcome.kind === "hitl")
+                hitl += 1;
         }
+        outcomes.push({
+            identifier: issue.identifier,
+            kind: resolved.outcome.kind,
+            detail: resolved.outcome.detail,
+        });
     }
     yield* printExitSummary(outcomes);
+    // VA-386: counter attributes on the drain span so the dashboard's
+    // drain row carries the same totals as runway's exit summary.
+    yield* Effect.annotateCurrentSpan({
+        "runway.drain.attempts": attempts,
+        "runway.drain.opened": opened,
+        "runway.drain.hitl": hitl,
+        "runway.drain.errored": errored,
+    });
     return {
         attempts,
         opened,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valescoagency/runway",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Linear-driven orchestrator + scaffolder for coding agents on Sandcastle. `runway init` scaffolds a target repo (sandcastle + varlock + 1Password); `runway run` drains a Linear queue against it; `runway doctor`, `runway upgrade`, `runway upgrade-repo` round out the lifecycle.",
   "license": "MIT",
   "author": {
@@ -43,7 +43,7 @@
     "@effect/opentelemetry": "^0.63.0",
     "@linear/sdk": "^84.0.0",
     "@opentelemetry/api": "^1.9.1",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.217.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.218.0",
     "@opentelemetry/resources": "^2.7.1",
     "@opentelemetry/sdk-trace-base": "^2.7.1",
     "@opentelemetry/sdk-trace-node": "^2.7.1",