@valescoagency/runway 0.10.0 → 0.10.1

package/README.md

@@ -392,7 +392,7 @@ These are tractable, just not v1.
 
 ## Status
 
-0.10.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/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) {
@@ -140,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
@@ -196,7 +204,14 @@ 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));

package/dist/git.js

@@ -77,6 +77,28 @@ export const captureCommitLog = (repoPath, base, branch) => runExecaScoped("git"
     const raw = res.stdout;
     return typeof raw === "string" ? raw : "";
 }));
+/**
+ * VA-421: Whether a branch ref exists on `origin`. Used by
+ * `fetchReady` to distinguish "an agent branch has been pushed (real
+ * work in flight, leave alone)" from "Linear auto-transitioned an
+ * issue to In-Progress without any work actually starting (drain
+ * it)". `git ls-remote --heads origin <branch>` is the cheapest
+ * authoritative check — one round-trip, no clone needed, SSH
+ * multiplexing usually caches the connection.
+ *
+ * Non-zero exit (network error, no remote configured, auth failure)
+ * surfaces as an Effect failure so the caller can route it through
+ * the usual error path rather than silently falling back to "doesn't
+ * exist" — operator should fix the env, not have runway quietly
+ * misclassify candidates.
+ */
+export const remoteRefExists = (repoPath, branch) => runExecaScoped("git", ["ls-remote", "--heads", "origin", branch], { cwd: repoPath }, (err) => ({
+    message: err instanceof Error ? err.message : String(err),
+})).pipe(Effect.map((res) => {
+    const raw = res.stdout;
+    const out = typeof raw === "string" ? raw : "";
+    return out.trim().length > 0;
+}));
 /**
  * VA-358: Whether the agent branch has any commits beyond `base`.
  * Used by failure-routing to distinguish "agent crashed mid-run,

package/dist/linear.js

@@ -232,7 +232,7 @@ function classifyLinearError(err, context) {
  * Production: `commands/run.ts` builds a limiter inside `Effect.scoped`
  * and passes it here.
  */
-export function createLinearGateway(config, limiter = null) {
+export function createLinearGateway(config, limiter = null, opts = {}) {
     const client = new LinearClient({ apiKey: Redacted.value(config.linearApiKey) });
     const gate = (eff) => (limiter ? limiter(eff) : eff);
     async function findStateId(teamId, name) {
@@ -300,18 +300,40 @@ export function createLinearGateway(config, limiter = null) {
                     const projectId = config.linearProject
                         ? await findProjectId(config.linearProject)
                         : null;
-                    const issues = await client.issues({
-                        filter: {
-                            team: { id: { eq: teamId } },
-                            state: { id: { eq: readyStateId } },
-                            ...(projectId ? { project: { id: { eq: projectId } } } : {}),
-                        },
+                    // VA-421: optionally accept In-Progress issues whose
+                    // `agent/<id>` branch hasn't been pushed to origin yet.
+                    // Linear's GitHub integration auto-transitions issues to
+                    // In-Progress on unrelated PR-body mentions, which used
+                    // to silently drop them from the drain queue. The
+                    // git-side check is the authoritative signal that no
+                    // successful drain attempt is in flight.
+                    const inProgressStateId = opts.remoteAgentBranchExists
+                        ? await findStateId(teamId, config.inProgressStatus)
+                        : null;
+                    const issuesFilter = (stateId) => ({
+                        team: { id: { eq: teamId } },
+                        state: { id: { eq: stateId } },
+                        ...(projectId ? { project: { id: { eq: projectId } } } : {}),
+                    });
+                    const todoBatch = await client.issues({
+                        filter: issuesFilter(readyStateId),
                         // VA-420: order doesn't matter at the SDK call — Linear's
                         // `IssueOrderBy` enum doesn't expose `priority`, and the
                         // SDK type for this argument hides the ASC/DESC direction
                         // anyway. We re-sort the candidate set in JS below.
                         orderBy: "createdAt",
                     });
+                    const inProgressBatch = inProgressStateId
+                        ? await client.issues({
+                            filter: issuesFilter(inProgressStateId),
+                            orderBy: "createdAt",
+                        })
+                        : { nodes: [] };
+                    const tagged = [
+                        ...todoBatch.nodes.map((raw) => ({ raw, kind: "todo" })),
+                        ...inProgressBatch.nodes.map((raw) => ({ raw, kind: "inProgress" })),
+                    ];
+                    const issues = { nodes: tagged };
                     // VA-420: drain by Linear priority first, then by createdAt
                     // within a priority bucket. Linear's priority encoding is
                     // non-monotonic — `1 = Urgent, 2 = High, 3 = Medium,
@@ -320,12 +342,12 @@ export function createLinearGateway(config, limiter = null) {
                     // (operator intuition: Urgent first, unprioritised last).
                     // Within a bucket, oldest-first restores the FIFO intent.
                     const candidates = [...issues.nodes].sort((a, b) => {
-                        const pa = a.priority === 0 ? Infinity : a.priority;
-                        const pb = b.priority === 0 ? Infinity : b.priority;
+                        const pa = a.raw.priority === 0 ? Infinity : a.raw.priority;
+                        const pb = b.raw.priority === 0 ? Infinity : b.raw.priority;
                         if (pa !== pb)
                             return pa - pb;
-                        return (new Date(a.createdAt).getTime() -
-                            new Date(b.createdAt).getTime());
+                        return (new Date(a.raw.createdAt).getTime() -
+                            new Date(b.raw.createdAt).getTime());
                     });
                     // VA-360: validate every issue node through the schema —
                     // a single drifted issue surfaces as `LinearSchemaError`
@@ -340,13 +362,24 @@ export function createLinearGateway(config, limiter = null) {
                     // candidate go through the rate limiter and the retry
                     // policy alongside everything else.
                     const eligible = [];
-                    for (const raw of candidates) {
+                    for (const { raw, kind } of candidates) {
                         const i = decodeIssueNode(raw);
                         const labels = await fetchIssueLabelNames(raw);
                         if (labels.includes(config.hitlLabel))
                             continue;
                         if (await hasActiveBlocker(raw))
                             continue;
+                        // VA-421: In-Progress candidates pass only if no
+                        // `agent/<id>` ref exists on origin — that's the
+                        // authoritative "no drain attempt in flight" signal,
+                        // immune to Linear's auto-transitions. Todo candidates
+                        // skip this check (no behavior change for the common
+                        // path).
+                        if (kind === "inProgress" && opts.remoteAgentBranchExists) {
+                            const branch = `agent/${i.identifier.toLowerCase()}`;
+                            if (await opts.remoteAgentBranchExists(branch))
+                                continue;
+                        }
                         eligible.push({
                             id: i.id,
                             identifier: i.identifier,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valescoagency/runway",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "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": {