@valescoagency/runway 0.9.0 → 0.10.1

package/README.md

@@ -392,7 +392,7 @@ These are tractable, just not v1.
 
 ## Status
 
-0.9.0 — production-shaped and dogfooded against live Linear queues.
+0.10.1 — 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/cli.js

@@ -84,5 +84,6 @@ async function main() {
 }
 main().catch((err) => {
     console.error("[runway] fatal:", err instanceof Error ? err.message : err);
+    console.error("[runway:exit] status=failure");
     process.exit(1);
 });

package/dist/commands/run.js

@@ -2,6 +2,7 @@ import { Effect, Layer, Logger, RateLimiter } from "effect";
 import { ConfigLive, ConfigTag } from "../config.js";
 import { createLinearGateway } from "../linear.js";
 import { createGithubGateway } from "../github.js";
+import { remoteRefExists } from "../git.js";
 import { assertSandcastleInitialised, drainQueue, } from "../orchestrator.js";
 import { TelemetryLive } from "../telemetry.js";
 export function parseRunArgs(argv) {
@@ -68,6 +69,25 @@ export function parseRunArgs(argv) {
             }
             opts.implTurns = n;
         }
+        else if (a === "--review-retries") {
+            const v = argv[i + 1];
+            if (!v)
+                throw new Error("--review-retries requires a number");
+            const n = Number.parseInt(v, 10);
+            if (!Number.isFinite(n) || n < 0) {
+                throw new Error(`--review-retries must be a non-negative integer, got "${v}"`);
+            }
+            opts.reviewRetries = n;
+            i += 1;
+        }
+        else if (a?.startsWith("--review-retries=")) {
+            const v = a.slice("--review-retries=".length);
+            const n = Number.parseInt(v, 10);
+            if (!Number.isFinite(n) || n < 0) {
+                throw new Error(`--review-retries must be a non-negative integer, got "${v}"`);
+            }
+            opts.reviewRetries = n;
+        }
         else if (a === "--help" || a === "-h") {
             printRunUsage();
             process.exit(0);
@@ -102,6 +122,14 @@ OPTIONS
                   (how many turns the Claude agent gets per attempt
                   before it has to signal IMPL: DONE / BLOCKED).
                   Overrides RUNWAY_IMPL_TURNS. Default: 3.
+  --review-retries N
+                  In-run review-rejection retry budget. When the
+                  reviewer emits REVIEW: REJECTED-RETRY — <reason>
+                  (mechanically fixable), runway re-runs the impl
+                  agent with the reason in {{IN_RUN_REVIEWER_FEEDBACK}}
+                  and re-runs review. N caps the extra impl+review
+                  pairs per drain pickup. 0 disables retries entirely.
+                  Overrides RUNWAY_REVIEW_RETRIES. Default: 1.
   --help, -h      Show this help.
 
 ENVIRONMENT
@@ -113,7 +141,14 @@ ENVIRONMENT
                               and targets with PRs). Detected from
                               origin/HEAD when unset.
   RUNWAY_READY_STATUS         default "Todo"
-  RUNWAY_IN_PROGRESS_STATUS   default "In Progress"
+  RUNWAY_IN_PROGRESS_STATUS   default "In Progress" — also the
+                              auxiliary drain bucket (VA-421): runway
+                              accepts issues in this status when no
+                              agent/<id> branch exists on origin, so
+                              Linear's GitHub auto-transitions (e.g.
+                              an unrelated PR mentioning the issue in
+                              its body) can't silently drop the issue
+                              from the queue.
   RUNWAY_IN_REVIEW_STATUS     default "In Review"
   RUNWAY_HITL_LABEL           default "ready-for-human"
   RUNWAY_MAX_ITERATIONS       default 5  — outer impl re-prompt loop
@@ -122,6 +157,11 @@ ENVIRONMENT
   RUNWAY_IMPL_TURNS           default 3  — sandcastle inner turn
                               budget per impl phase. Overridden by
                               --impl-turns.
+  RUNWAY_REVIEW_RETRIES       default 1  — review-rejection retry
+                              loop. On REVIEW: REJECTED-RETRY, runway
+                              re-runs impl with the rejection in the
+                              prompt, then re-runs review. 0 disables
+                              entirely. Overridden by --review-retries.
 `);
 }
 export async function runCommand(argv) {
@@ -152,6 +192,9 @@ export async function runCommand(argv) {
             ...baseConfig,
             ...(opts.project ? { linearProject: opts.project } : {}),
             ...(opts.implTurns !== undefined ? { implTurns: opts.implTurns } : {}),
+            ...(opts.reviewRetries !== undefined
+                ? { reviewRetries: opts.reviewRetries }
+                : {}),
         };
         const scope = config.linearProject
             ? `team ${config.linearTeam} / project ${config.linearProject}`
@@ -161,10 +204,29 @@ export async function runCommand(argv) {
             limit: 30,
             interval: "1 minute",
         });
-        const linear = createLinearGateway(config, linearLimiter);
+        // VA-421: inject a git-side predicate so `fetchReady` can accept
+        // In-Progress issues whose `agent/<id>` branch hasn't yet been
+        // pushed to origin. Closes the Linear-auto-transition loophole
+        // where an unrelated PR-body mention silently drops an issue from
+        // the drain queue.
+        const linear = createLinearGateway(config, linearLimiter, {
+            remoteAgentBranchExists: (branch) => Effect.runPromise(remoteRefExists(cwd, branch)),
+        });
         const github = createGithubGateway();
         return yield* drainQueue({ config, linear, github, cwd }, { max: opts.max, allowPaths: opts.allowPaths });
     }).pipe(Effect.scoped, Effect.provide(MainLayer));
     const result = await Effect.runPromise(program);
     console.log(`[runway] done — attempts=${result.attempts} opened=${result.opened} hitl=${result.hitl} errored=${result.errored}`);
+    // Single-line, parser-friendly completion marker. Background
+    // watchers (Claude Code's `run_in_background` bash task, CI,
+    // scripts) can grep for `[runway:exit]` instead of guessing
+    // whether the drain is still in flight.
+    console.log(`[runway:exit] status=success attempts=${result.attempts} opened=${result.opened} hitl=${result.hitl} errored=${result.errored}`);
+    // Hard exit so any lingering handle (OTel BatchSpanProcessor's
+    // interval when OTEL_EXPORTER_OTLP_ENDPOINT is set, a Docker
+    // stream Sandcastle left open, etc.) can't keep the process — and
+    // the background task that launched it — alive after the drain is
+    // logically done. By this point `Effect.scoped` has already torn
+    // down its finalizers.
+    process.exit(0);
 }

package/dist/config.js

@@ -24,6 +24,13 @@ const configEffect = EConfig.all({
         message: "RUNWAY_IMPL_TURNS must be a positive integer",
         validation: (n) => n > 0,
     })),
+    // VA-418: zero is a valid value here (operator kill-switch) so the
+    // validation accepts >= 0, unlike implTurns/maxIterations which
+    // both require >= 1.
+    reviewRetries: EConfig.integer("RUNWAY_REVIEW_RETRIES").pipe(EConfig.withDefault(1), EConfig.validate({
+        message: "RUNWAY_REVIEW_RETRIES must be a non-negative integer",
+        validation: (n) => n >= 0,
+    })),
     commentAuthorAllowlist: EConfig.option(EConfig.string("RUNWAY_COMMENT_AUTHOR_ALLOWLIST")),
 }).pipe(Effect.map((raw) => ({
     linearApiKey: raw.linearApiKey,
@@ -37,6 +44,7 @@ const configEffect = EConfig.all({
     hitlLabel: raw.hitlLabel,
     maxIterations: raw.maxIterations,
     implTurns: raw.implTurns,
+    reviewRetries: raw.reviewRetries,
     commentAuthorAllowlist: Option.getOrUndefined(raw.commentAuthorAllowlist)
         ?.split(",")
         .map((s) => s.trim())

package/dist/dashboard/otlp.js

@@ -11,12 +11,18 @@
 /**
  * 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.
+ * `doubleValue` / `arrayValue`) 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.
+ *
+ * VA-387: `arrayValue` collapses to a `readonly string[]` so the
+ * dashboard's label-style attributes (`runway.issue.labels`) survive
+ * the wire trip with their structure intact. Non-string array
+ * elements drop silently — projector callers only ever ask for
+ * string arrays today.
  */
 export function attrValue(attr) {
     if (!attr)
@@ -35,6 +41,14 @@ export function attrValue(attr) {
             ? v.intValue
             : v.intValue;
     }
+    if (v.arrayValue !== undefined) {
+        const items = [];
+        for (const inner of v.arrayValue.values) {
+            if (inner.stringValue !== undefined)
+                items.push(inner.stringValue);
+        }
+        return items;
+    }
     return undefined;
 }
 /**

package/dist/dashboard/projector.js

@@ -78,9 +78,13 @@ function projectIssueProcess(span) {
         parentSpanId: span.parentSpanId ?? null,
         issueIdentifier: identifier,
         issueId: strAttr(m["runway.issue.id"]) ?? null,
+        issueTitle: strAttr(m["runway.issue.title"]) ?? null,
+        issueLabels: strArrayAttr(m["runway.issue.labels"]),
         branch: strAttr(m["runway.branch"]) ?? null,
         outcomeKind: strAttr(m["runway.outcome.kind"]) ?? null,
         outcomeDetail: strAttr(m["runway.outcome.detail"]) ?? null,
+        prUrl: strAttr(m["runway.pr.url"]) ?? null,
+        hitlReason: strAttr(m["runway.hitl.reason"]) ?? null,
         startTimeUnixNano: span.startTimeUnixNano,
         endTimeUnixNano: span.endTimeUnixNano,
         statusCode: span.status?.code ?? null,
@@ -125,3 +129,11 @@ function numAttr(v) {
     }
     return null;
 }
+/**
+ * VA-387: decode an OTLP arrayValue attribute into a string array.
+ * Older spans (or spans from a runway that never set the attribute)
+ * become an empty list so callers don't have to null-guard.
+ */
+function strArrayAttr(v) {
+    return Array.isArray(v) ? v : [];
+}

package/dist/dashboard/server.js

@@ -6,6 +6,10 @@ import { renderDetailView, renderListView } from "./views.js";
 // Anything else stays in raw_spans for debugging but isn't rendered.
 const DETAIL_PHASE_NAMES = ["review", "pushBranch", "openPullRequest"];
 const ISSUE_DETAIL_RE = /^\/issue\/([^/?#]+)\/([^/?#]+)\/?$/;
+// VA-387: canonical detail route. `:id` is the issue process span_id;
+// the lookup falls back to the (trace_id, span_id) pair only for
+// older `/issue/...` links that still work for back-compat.
+const ISSUE_PROCESS_DETAIL_RE = /^\/issue-processes\/([^/?#]+)\/?$/;
 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
@@ -58,7 +62,14 @@ async function handle(req, res, storage) {
         return;
     }
     if (method === "GET") {
-        const detailMatch = ISSUE_DETAIL_RE.exec(url.split("?")[0] ?? "");
+        const pathOnly = url.split("?")[0] ?? "";
+        const issueProcessMatch = ISSUE_PROCESS_DETAIL_RE.exec(pathOnly);
+        if (issueProcessMatch) {
+            const spanId = decodeURIComponent(issueProcessMatch[1] ?? "");
+            handleIssueProcessDetailView(res, storage, spanId);
+            return;
+        }
+        const detailMatch = ISSUE_DETAIL_RE.exec(pathOnly);
         if (detailMatch) {
             const traceId = decodeURIComponent(detailMatch[1] ?? "");
             const spanId = decodeURIComponent(detailMatch[2] ?? "");
@@ -66,6 +77,10 @@ async function handle(req, res, storage) {
             return;
         }
     }
+    if (method === "GET" && (url === "/api/aggregates" || url.startsWith("/api/aggregates?"))) {
+        handleAggregates(res, storage);
+        return;
+    }
     if (method === "GET" && url === "/healthz") {
         res.writeHead(200, { "content-type": "text/plain" });
         res.end("ok");
@@ -136,8 +151,24 @@ function handleDetailView(res, storage, traceId, spanId) {
         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, [
+    renderDetailFor(res, storage, ip);
+}
+/**
+ * VA-387: detail-route handler keyed on the issue process span_id
+ * alone. Reuses the same view model as the older two-segment route
+ * once the row is resolved.
+ */
+function handleIssueProcessDetailView(res, storage, spanId) {
+    const ip = storage.getIssueProcessBySpanId(spanId);
+    if (!ip) {
+        writeError(res, 404, "not_found", `no issue process for span=${spanId}`);
+        return;
+    }
+    renderDetailFor(res, storage, ip);
+}
+function renderDetailFor(res, storage, ip) {
+    const iterations = storage.listAgentIterations(ip.traceId, ip.spanId);
+    const phaseSpans = storage.listPhaseSpans(ip.traceId, ip.spanId, [
         ...DETAIL_PHASE_NAMES,
     ]);
     const html = renderDetailView({
@@ -148,6 +179,18 @@ function handleDetailView(res, storage, traceId, spanId) {
     res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
     res.end(html);
 }
+/**
+ * VA-399: JSON snapshot of the evaluator-facing aggregates read-model.
+ * The shape mirrors `EvaluatorAggregate` (snake_case → camelCase) so
+ * IRA prompts and the dashboard UI can reference the same field names
+ * regardless of access path. See `read-model.md` for the field
+ * contract + versioning policy.
+ */
+function handleAggregates(res, storage) {
+    const rows = storage.listAggregates();
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify({ view: "evaluator_aggregates_v1", rows }));
+}
 async function readBody(req) {
     const chunks = [];
     let total = 0;
@@ -184,7 +227,14 @@ 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);
+    // VA-399: rolling-window size for the evaluator aggregates view.
+    // Defaults to 30 drains; operators bump it for longer-baseline IRA
+    // comparisons. Missing/invalid → fall through to the storage layer's
+    // default rather than crashing the dashboard at boot.
+    const aggregateWindow = parsePositiveInt(process.env.DASHBOARD_AGGREGATE_WINDOW);
+    const storage = createStorage(sqlitePath, {
+        aggregateWindowDrains: aggregateWindow,
+    });
     const otlp = await startServer({ storage, port: otlpPort });
     const dashboard = dashboardPort === otlpPort
         ? otlp
@@ -209,6 +259,12 @@ function parsePort(envName, fallback) {
     }
     return n;
 }
+function parsePositiveInt(raw) {
+    if (!raw)
+        return undefined;
+    const n = Number.parseInt(raw, 10);
+    return Number.isFinite(n) && n > 0 ? n : undefined;
+}
 // Run as a script when executed directly (e.g. inside the Docker
 // container's CMD). Skipped when imported by tests.
 const isMain = (() => {