@valescoagency/runway 0.7.0 → 0.7.1

package/README.md

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

@@ -26,6 +26,17 @@ const IssueLabelNodeSchema = Schema.Struct({
 const ProjectNodeSchema = Schema.Struct({
     id: Schema.String,
 });
+// VA-394: minimal shape needed to ask "is this blocker still active?"
+// — we only read the relation's `type` (filtering for `blocks`) and
+// the related issue's workflow state `type`. Schemas stay narrow so
+// the validation cost per candidate stays small.
+const IssueRelationNodeSchema = Schema.Struct({
+    id: Schema.String,
+    type: Schema.String,
+});
+const WorkflowStateTypeNodeSchema = Schema.Struct({
+    type: Schema.String,
+});
 // VA-383: comments fetched for surfacing prior-attempt review feedback
 // to the implementer. `user` is nullable on Linear's side (system /
 // integration comments can lack an author); we map a missing user to
@@ -51,6 +62,56 @@ const decodeIssueLabelNode = Schema.decodeUnknownSync(IssueLabelNodeSchema);
 const decodeProjectNode = Schema.decodeUnknownSync(ProjectNodeSchema);
 const decodeCommentNode = Schema.decodeUnknownSync(CommentNodeSchema);
 const decodeViewer = Schema.decodeUnknownSync(ViewerSchema);
+const decodeIssueRelationNode = Schema.decodeUnknownSync(IssueRelationNodeSchema);
+const decodeWorkflowStateTypeNode = Schema.decodeUnknownSync(WorkflowStateTypeNodeSchema);
+// VA-394: Linear workflow state `type` values that mean "the blocker
+// has resolved." Anything else (`triage`, `backlog`, `unstarted`,
+// `started`) still gates the blocked issue from runway pickup.
+const TERMINAL_STATE_TYPES = new Set(["completed", "canceled"]);
+const isTerminalStateType = (type) => TERMINAL_STATE_TYPES.has(type);
+/**
+ * VA-394: returns true when `issue` carries `hitlLabel`. Runway writes
+ * this label on HITL escapes, and triage may apply it to flag
+ * human-only work — either way the contract is "do not pick up." Uses
+ * the SDK's chained `labels()` call rather than asking for labels
+ * inline at the candidate-fetch site so the schema for `IssueNode`
+ * stays narrow.
+ */
+async function hasHitlLabel(issue, hitlLabel) {
+    const labels = await issue.labels();
+    for (const raw of labels.nodes) {
+        if (decodeIssueLabelNode(raw).name === hitlLabel)
+            return true;
+    }
+    return false;
+}
+/**
+ * VA-394: returns true when `issue` has at least one `inverseRelations`
+ * record of type `blocks` whose blocker is in a non-terminal workflow
+ * state. Other relation types (`duplicate`, `related`) do not gate
+ * pickup. A blocker with a missing or undecodable state is treated as
+ * inactive (best-effort: drift in one relation should not stop the
+ * queue), but the decoder still throws `ParseError` on outright
+ * malformed relation nodes — caught upstream as `LinearSchemaError`.
+ */
+async function hasActiveBlocker(issue) {
+    const relations = await issue.inverseRelations();
+    for (const rawRel of relations.nodes) {
+        const rel = decodeIssueRelationNode(rawRel);
+        if (rel.type !== "blocks")
+            continue;
+        const blocker = await rawRel.issue;
+        if (!blocker)
+            continue;
+        const blockerState = await blocker.state;
+        if (!blockerState)
+            continue;
+        const stateType = decodeWorkflowStateTypeNode(blockerState).type;
+        if (!isTerminalStateType(stateType))
+            return true;
+    }
+    return false;
+}
 export class LinearNotFound extends Data.TaggedError("LinearNotFound") {
 }
 export class LinearUnauthorized extends Data.TaggedError("LinearUnauthorized") {
@@ -239,15 +300,30 @@ export function createLinearGateway(config, limiter = null) {
                     // VA-360: validate every issue node through the schema —
                     // a single drifted issue surfaces as `LinearSchemaError`
                     // instead of a downstream `cannot read property X`.
-                    return issues.nodes.map((raw) => {
+                    //
+                    // VA-394: per-candidate eligibility — skip issues carrying
+                    // `config.hitlLabel` (triage's "human-only" marker, also
+                    // applied by runway itself on prior HITL escapes), and
+                    // skip issues with at least one active `blocks` relation
+                    // pointing at them. The candidate set is the Todo queue,
+                    // typically a handful of issues; the N+1 SDK calls per
+                    // candidate go through the rate limiter and the retry
+                    // policy alongside everything else.
+                    const eligible = [];
+                    for (const raw of issues.nodes) {
                         const i = decodeIssueNode(raw);
-                        return {
+                        if (await hasHitlLabel(raw, config.hitlLabel))
+                            continue;
+                        if (await hasActiveBlocker(raw))
+                            continue;
+                        eligible.push({
                             id: i.id,
                             identifier: i.identifier,
                             title: i.title,
                             description: i.description ?? "",
-                        };
-                    });
+                        });
+                    }
+                    return eligible;
                 },
                 catch: (err) => classifyLinearError(err, "fetchReady"),
             }), { call: "fetchReady" }));

package/package.json

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