npm - @valescoagency/runway - Versions diffs - 0.9.0 → 0.10.0 - Mend

@valescoagency/runway 0.9.0 → 0.10.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/README.md +1 -1
package/dist/cli.js +1 -0
package/dist/commands/run.js +47 -0
package/dist/config.js +8 -0
package/dist/dashboard/otlp.js +16 -2
package/dist/dashboard/projector.js +12 -0
package/dist/dashboard/server.js +60 -4
package/dist/dashboard/storage.js +233 -17
package/dist/dashboard/views.js +18 -1
package/dist/finalize.js +34 -2
package/dist/git.js +170 -22
package/dist/implement.js +6 -0
package/dist/linear.js +35 -9
package/dist/orchestrator.js +99 -18
package/dist/prompts.js +40 -0
package/dist/review.js +32 -18
package/package.json +1 -1
package/prompts/implement.md +11 -0
package/prompts/review.md +48 -6

package/dist/dashboard/views.js CHANGED Viewed

@@ -60,7 +60,8 @@ export function renderListView(rows) {
 function renderRow(r) {
     const kind = r.outcomeKind ?? "pending";
     const outcomeCls = `outcome outcome-${escapeHtml(kind)}`;
-    const href = `/issue/${encodeURIComponent(r.traceId)}/${encodeURIComponent(r.spanId)}`;
+    // VA-387: canonical detail link uses the span_id alone.
+    const href = `/issue-processes/${encodeURIComponent(r.spanId)}`;
     return `<tr>
     <td class="id"><a href="${escapeHtml(href)}">${escapeHtml(r.issueIdentifier)}</a></td>
     <td class="${outcomeCls}">${escapeHtml(kind)}</td>
@@ -83,6 +84,18 @@ export function renderDetailView(vm) {
     const ip = vm.issueProcess;
     const kind = ip.outcomeKind ?? "pending";
     const outcomeCls = `outcome outcome-${escapeHtml(kind)}`;
+    const titleLine = ip.issueTitle
+        ? `<div class="title">${escapeHtml(ip.issueTitle)}</div>`
+        : "";
+    const prLine = ip.prUrl
+        ? `<div><span class="label">PR:</span><a href="${escapeHtml(ip.prUrl)}" rel="noopener noreferrer" target="_blank">${escapeHtml(ip.prUrl)}</a></div>`
+        : "";
+    // HITL reason is only rendered when present (HITL or errored runs).
+    // For opened/reverted outcomes we omit the row entirely rather than
+    // showing an empty label.
+    const hitlLine = ip.hitlReason
+        ? `<div><span class="label">HITL reason:</span><span class="detail">${escapeHtml(ip.hitlReason)}</span></div>`
+        : "";
     return `<!doctype html>
 <html lang="en">
 <head>
@@ -90,6 +103,7 @@ export function renderDetailView(vm) {
   <title>${escapeHtml(ip.issueIdentifier)} · runway dashboard</title>
   <style>${SHARED_STYLE}
     .breadcrumb { color: #9ca3af; margin-bottom: 16px; font-size: 12px; }
+    .title { font-size: 14px; color: #d4d4d8; margin: -8px 0 12px; }
     .meta { margin: 4px 0 16px; }
     .meta .label { color: #9ca3af; margin-right: 4px; }
     .timeline { position: relative; height: 28px; background: #18181b;
@@ -113,8 +127,11 @@ export function renderDetailView(vm) {
 <body>
   <div class="breadcrumb"><a href="/">← all issue processes</a></div>
   <h1>${escapeHtml(ip.issueIdentifier)} · <span class="${outcomeCls}">${escapeHtml(kind)}</span></h1>
+  ${titleLine}
   <div class="meta">
     <div><span class="label">branch:</span><code>${escapeHtml(ip.branch ?? "—")}</code></div>
+    ${prLine}
+    ${hitlLine}
     <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>

package/dist/finalize.js CHANGED Viewed

@@ -1,10 +1,23 @@
 import { Effect } from "effect";
+import { rebaseOntoBase } from "./git.js";
 /**
- * Push the agent branch, open the PR, transition the Linear issue to
- * the in-review status, and link the PR back on the issue.
+ * VA-419: rebase the agent branch onto the latest `origin/<baseBranch>`,
+ * then push and open the PR. If the rebase hits a conflict, restore
+ * pre-rebase state and surface a `rebase-conflict` outcome — the
+ * orchestrator routes it to HITL so the operator can reconcile
+ * manually (or let VA-417 reset the branch on the next drain).
  */
 export const finalize = (issue, deps, branch) => Effect.gen(function* () {
     const { config, cwd, baseBranch, linear, github } = deps;
+    const rebase = yield* rebaseOntoBase(cwd, baseBranch, branch).pipe(Effect.withSpan("rebaseOntoBase"));
+    if (rebase.kind === "conflict") {
+        return {
+            kind: "rebase-conflict",
+            baseBranch,
+            conflictedFiles: rebase.conflictedFiles,
+            reviewVerdict: "REVIEW: APPROVED",
+        };
+    }
     yield* github.pushBranch(cwd, branch).pipe(Effect.withSpan("pushBranch"));
     const prBody = buildPrBody(issue);
     const prUrl = yield* github
@@ -20,6 +33,25 @@ 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 };
 });
+/**
+ * VA-419: format the HITL message body for a rebase-conflict outcome.
+ * Names the base branch and the conflicted file list, and quotes the
+ * reviewer's APPROVED verdict so the operator knows the agent's diff
+ * was good before the conflict surfaced.
+ */
+export function formatRebaseConflictReason(args) {
+    const fileLines = args.conflictedFiles.length
+        ? args.conflictedFiles.map((f) => `  - ${f}`).join("\n")
+        : "  (no conflicted files reported by git — inspect manually)";
+    return [
+        `Upstream base \`${args.baseBranch}\` advanced during this drain; the rebase`,
+        "onto the latest base produced conflicts in:",
+        fileLines,
+        `Review was APPROVED before the rebase (\`${args.reviewVerdict}\`); the agent's diff`,
+        "is good but needs operator reconciliation against the new base. Re-run runway",
+        "after rebasing manually, or let VA-417 handle it on the next drain.",
+    ].join("\n");
+}
 // 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.

package/dist/git.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { Data, Effect } from "effect";
+import { Data, Effect, Option } from "effect";
 import { runExecaScoped } from "./subprocess.js";
 /**
  * VA-358: thin typed error for `detectBaseBranch`. We don't model
@@ -95,23 +95,82 @@ export const hasCommits = (repoPath, base, branch) => runExecaScoped("git", ["re
     return Number.parseInt(out.trim(), 10) > 0;
 }));
 /**
- * VA-366: prune an agent/<issue> branch from a prior failed attempt
- * so the next worktree creation forks from current `base` HEAD
- * instead of reusing a stale tip.
+ * VA-419: fetch the latest `origin/<baseBranch>` and rebase the agent
+ * branch onto it. Closes the upstream-conflict-after-approval gap —
+ * without this step, a PR opened off `agent/<id>` after another PR
+ * merged to base mid-drain can land in `CONFLICTING` state on
+ * creation.
+ *
+ * Layout: this runs in the host repo (`repoPath`), not in a sandcastle
+ * worktree. The agent branch is a local ref; `git rebase <upstream>
+ * <branch>` checks it out before replaying commits. Host cwd HEAD is
+ * left wherever the rebase put it (typically on the agent branch on
+ * success, or restored by `--abort` on conflict) — finalize's push
+ * only cares about the ref, not the working-tree HEAD.
+ *
+ * The fetch step may fail (network blip, gh auth expired). We let
+ * that error bubble — finalize routes it through the existing
+ * processIssue failure path. A non-zero rebase exit is treated as
+ * "conflict" regardless of cause, since the safe response is the
+ * same: abort and route to HITL.
+ */
+export const rebaseOntoBase = (repoPath, baseBranch, branch) => Effect.gen(function* () {
+    yield* runExecaScoped("git", ["fetch", "origin", baseBranch], { cwd: repoPath }, (err) => ({
+        message: err instanceof Error ? err.message : String(err),
+    }));
+    const rebase = yield* runExecaScoped("git", ["rebase", `origin/${baseBranch}`, branch], { cwd: repoPath, reject: false }, (err) => ({
+        message: err instanceof Error ? err.message : String(err),
+    }));
+    if (rebase.exitCode === 0) {
+        return { kind: "ok" };
+    }
+    // Collect the unmerged file list before aborting — `--diff-filter=U`
+    // matches only files git left in conflict state.
+    const conflictedFiles = yield* runExecaScoped("git", ["diff", "--name-only", "--diff-filter=U"], { cwd: repoPath, reject: false }, (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
+            .split("\n")
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0);
+    }), Effect.catchAll(() => Effect.succeed([])));
+    yield* runExecaScoped("git", ["rebase", "--abort"], { cwd: repoPath, reject: false }, (err) => ({
+        message: err instanceof Error ? err.message : String(err),
+    })).pipe(Effect.catchAll(() => Effect.succeed(undefined)));
+    return { kind: "conflict", conflictedFiles };
+});
+/**
+ * VA-417: typed failure when neither `origin/<base>` nor local `<base>`
+ * resolves to a SHA in the local refs database. The orchestrator dies
+ * the drain on this — the alternative (silently skip the reset) would
+ * re-trigger the no-op-on-retry pattern this fix exists to close.
+ */
+export class AgentBranchResetTargetUnreachable extends Data.TaggedError("AgentBranchResetTargetUnreachable") {
+}
+/**
+ * VA-366 + VA-417: ensure an `agent/<issue>` branch starts from a
+ * known-good base before sandcastle's worktree creation reuses it.
  *
  * Logic:
- *   1. If the branch doesn't exist → no-op.
- *   2. If it has commits ahead of `base` (`hasCommits` returns true)
- *      → preserve. Agent did real work; resetting would discard it.
- *   3. Otherwise (branch present, no commits ahead) → `git branch -D`.
- *      `-D` (not `-d`) because the branch tip equals or trails base
- *      after the failed attempt, and `-d`'s merge check can refuse
- *      otherwise-equivalent tips.
+ *   1. Branch doesn't exist → no-op (first-attempt case).
+ *   2. Branch exists, zero commits ahead of `base` → VA-366: delete
+ *      so the next worktree creation forks from current base HEAD
+ *      instead of an old base tip.
+ *   3. Branch exists with commits ahead of `base` → VA-417: those
+ *      commits come from a prior attempt that review rejected
+ *      (`fetchReady` filters out open PRs / non-Todo states, so any
+ *      surviving commits here are from a HITL'd retry). Detach any
+ *      worktree still attached to the branch, then reset the ref to
+ *      `origin/<base>` (or local `<base>` as fallback) so the impl
+ *      agent doesn't treat the rejected diff as authoritative.
  *
- * Best-effort: this is a *retry hygiene* operation, not a correctness
- * guarantee. If git fails, we log and continue — sandcastle's
- * worktree creation will still work; the agent just sees the stale
- * branch state that motivated this fix.
+ * Steps 1 + 2 stay best-effort — git failures inside them log and
+ * continue (the existing VA-366 contract). Step 3's reset-target
+ * resolution surfaces a typed `AgentBranchResetTargetUnreachable`;
+ * the orchestrator dies on it so the operator fixes the env rather
+ * than re-trigger the no-op pattern.
  */
 export const pruneStaleAgentBranch = (repoPath, base, branch) => Effect.gen(function* () {
     // 1. Existence check.
@@ -120,14 +179,103 @@ export const pruneStaleAgentBranch = (repoPath, base, branch) => Effect.gen(func
     })).pipe(Effect.map((res) => res.exitCode === 0), Effect.catchAll(() => Effect.succeed(false)));
     if (!exists)
         return;
-    // 2. Preserve if the branch carries real work.
-    const hasWork = yield* hasCommits(repoPath, base, branch).pipe(
-    // If we can't tell, prefer the safe option — keep the branch.
-    Effect.catchAll(() => Effect.succeed(true)));
-    if (hasWork)
+    // 2. Ahead-count. `Effect.option` distinguishes "definitively zero
+    // / non-zero" from "couldn't determine"; in the latter case we
+    // bail to avoid acting destructively on uncertain state.
+    const hasWorkOpt = yield* hasCommits(repoPath, base, branch).pipe(Effect.option);
+    if (Option.isNone(hasWorkOpt))
+        return;
+    if (!hasWorkOpt.value) {
+        // VA-366: branch is at-or-behind base — delete so sandcastle's
+        // next worktree creation forks from current base HEAD.
+        yield* runExecaScoped("git", ["branch", "-D", branch], { cwd: repoPath, reject: false }, (err) => ({
+            message: err instanceof Error ? err.message : String(err),
+        })).pipe(Effect.catchAll(() => Effect.succeed(undefined)));
+        return;
+    }
+    // 3. VA-417: commits ahead of base come from a HITL-rejected
+    // prior attempt. Resolve the reset target first so we fail loudly
+    // (typed) before touching any worktree state.
+    const target = yield* resolveResetTarget(repoPath, base);
+    // 3a. Detach any worktree still attached to this branch — its
+    // working tree would otherwise diverge from the new ref and
+    // sandcastle would reuse it dirty (ADR 0003 reuse-with-warning).
+    yield* removeAttachedWorktree(repoPath, branch);
+    // 3b. Move the ref. `update-ref` (rather than `branch -f`) works
+    // regardless of whether step 3a actually succeeded in detaching
+    // every worktree; sandcastle's collision check still has to pass
+    // before any agent code runs.
+    yield* runExecaScoped("git", ["update-ref", `refs/heads/${branch}`, target], { cwd: repoPath, reject: false }, (err) => ({
+        message: err instanceof Error ? err.message : String(err),
+    })).pipe(Effect.catchAll(() => Effect.succeed(undefined)));
+});
+/**
+ * VA-417: resolve the SHA we'll point the agent branch at. Try
+ * `origin/<base>` first (canonical source for HITL-retry resets);
+ * fall back to local `<base>` so a fresh / offline clone with no
+ * configured remote can still recover. Surface a typed error if
+ * neither resolves — silent skipping would re-trigger the no-op
+ * pattern.
+ */
+const resolveResetTarget = (repoPath, base) => Effect.gen(function* () {
+    const originRef = `refs/remotes/origin/${base}`;
+    const originReachable = yield* runExecaScoped("git", ["rev-parse", "--verify", originRef], { cwd: repoPath, reject: false }, (err) => ({
+        message: err instanceof Error ? err.message : String(err),
+    })).pipe(Effect.map((res) => res.exitCode === 0), Effect.catchAll(() => Effect.succeed(false)));
+    if (originReachable)
+        return originRef;
+    const localRef = `refs/heads/${base}`;
+    const localReachable = yield* runExecaScoped("git", ["rev-parse", "--verify", localRef], { cwd: repoPath, reject: false }, (err) => ({
+        message: err instanceof Error ? err.message : String(err),
+    })).pipe(Effect.map((res) => res.exitCode === 0), Effect.catchAll(() => Effect.succeed(false)));
+    if (localReachable)
+        return localRef;
+    return yield* Effect.fail(new AgentBranchResetTargetUnreachable({
+        base,
+        message: `Cannot reset stale agent branch: neither ${originRef} nor ` +
+            `${localRef} resolves in ${repoPath}. Run ` +
+            `\`git fetch origin ${base}\` (or set RUNWAY_BASE_BRANCH to ` +
+            `a branch that exists locally) and re-run.`,
+    }));
+});
+/**
+ * VA-417: if a worktree is checked out on `branch`, remove it so the
+ * branch ref can move freely. Best-effort — sandcastle's `pruneStale`
+ * runs later and will collide on a stale managed worktree, so the
+ * worst case here is "we tried, git refused, sandcastle warns".
+ */
+const removeAttachedWorktree = (repoPath, branch) => Effect.gen(function* () {
+    const list = yield* runExecaScoped("git", ["worktree", "list", "--porcelain"], { cwd: repoPath, reject: false }, (err) => ({
+        message: err instanceof Error ? err.message : String(err),
+    })).pipe(Effect.map((res) => (typeof res.stdout === "string" ? res.stdout : "")), Effect.catchAll(() => Effect.succeed("")));
+    const path = parseWorktreePathForBranch(list, branch);
+    if (!path)
         return;
-    // 3. Stale → delete so the next worktree creation forks from base HEAD.
-    yield* runExecaScoped("git", ["branch", "-D", branch], { cwd: repoPath, reject: false }, (err) => ({
+    yield* runExecaScoped("git", ["worktree", "remove", "--force", path], { cwd: repoPath, reject: false }, (err) => ({
         message: err instanceof Error ? err.message : String(err),
     })).pipe(Effect.catchAll(() => Effect.succeed(undefined)));
 });
+/**
+ * Parse `git worktree list --porcelain` output. Each entry is a
+ * `worktree <path>` line followed by metadata (`HEAD`, `branch
+ * refs/heads/<name>`, …) terminated by a blank line. Return the path
+ * of the first entry whose branch matches `branch`, or null.
+ */
+function parseWorktreePathForBranch(porcelain, branch) {
+    const refPrefix = "branch refs/heads/";
+    let currentPath = null;
+    for (const line of porcelain.split("\n")) {
+        if (line.startsWith("worktree ")) {
+            currentPath = line.slice("worktree ".length).trim();
+        }
+        else if (line.startsWith(refPrefix)) {
+            const name = line.slice(refPrefix.length).trim();
+            if (name === branch && currentPath)
+                return currentPath;
+        }
+        else if (line.trim() === "") {
+            currentPath = null;
+        }
+    }
+    return null;
+}

package/dist/implement.js CHANGED Viewed

@@ -45,6 +45,7 @@ export function parseImplVerdict(result) {
  */
 export const runImplementLoop = (issue, deps, branch) => Effect.gen(function* () {
     const { config, cwd, baseBranch, policy, priorFeedback } = deps;
+    const inRunReviewerFeedback = deps.inRunReviewerFeedback ?? "";
     const maxIters = Math.max(1, config.maxIterations);
     let prevSummary = "";
     let implementResult;
@@ -60,6 +61,11 @@ export const runImplementLoop = (issue, deps, branch) => Effect.gen(function* ()
             // and iteration N+1, since the implementer keeps drifting
             // toward the same code paths until corrected.
             priorReviewFeedback: priorFeedback,
+            // VA-418: in-run rejection feedback (empty on first impl
+            // pass, populated on a review-rejection retry). Independent
+            // slot from `priorReviewFeedback` so the agent reads it as
+            // the higher-trust signal.
+            inRunReviewerFeedback,
             // VA-417: pass the actual base branch so the prompt
             // renders the real name (`main`, `master`, etc.) rather
             // than a hardcoded default.

package/dist/linear.js CHANGED Viewed

@@ -10,6 +10,12 @@ const IssueNodeSchema = Schema.Struct({
     identifier: Schema.String,
     title: Schema.String,
     description: Schema.NullOr(Schema.String),
+    // VA-420: drain order is `priority ASC (Urgent=1 → Low=4, No-priority=0
+    // sorted last), then createdAt ASC`. The sort reads this off the raw
+    // SDK node; the schema entry narrows the field at the seam so a Linear
+    // API drift surfaces as `LinearSchemaError` instead of a silent NaN
+    // comparison.
+    priority: Schema.Number,
 });
 const WorkflowStateNodeSchema = Schema.Struct({
     id: Schema.String,
@@ -82,14 +88,14 @@ const isTerminalStateType = (type) => TERMINAL_STATE_TYPES.has(type);
  * the SDK's chained `labels()` call rather than asking for labels
  * inline at the candidate-fetch site so the schema for `IssueNode`
  * stays narrow.
+ *
+ * VA-387: pulls all label names so callers that need the full list
+ * (the dashboard's `runway.issue.labels` attribute) don't have to
+ * re-issue the SDK call.
  */
-async function hasHitlLabel(issue, hitlLabel) {
+async function fetchIssueLabelNames(issue) {
     const labels = await issue.labels();
-    for (const raw of labels.nodes) {
-        if (decodeIssueLabelNode(raw).name === hitlLabel)
-            return true;
-    }
-    return false;
+    return labels.nodes.map((raw) => decodeIssueLabelNode(raw).name);
 }
 /**
  * VA-394: returns true when `issue` has at least one `inverseRelations`
@@ -300,9 +306,27 @@ export function createLinearGateway(config, limiter = null) {
                             state: { id: { eq: readyStateId } },
                             ...(projectId ? { project: { id: { eq: projectId } } } : {}),
                         },
-                        // Stable order: oldest first so the queue drains FIFO.
+                        // 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",
                     });
+                    // 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,
+                    // 4 = Low, 0 = No priority` — so `0` is remapped to
+                    // `Infinity` to sit behind every prioritised bucket
+                    // (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;
+                        if (pa !== pb)
+                            return pa - pb;
+                        return (new Date(a.createdAt).getTime() -
+                            new Date(b.createdAt).getTime());
+                    });
                     // VA-360: validate every issue node through the schema —
                     // a single drifted issue surfaces as `LinearSchemaError`
                     // instead of a downstream `cannot read property X`.
@@ -316,9 +340,10 @@ 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 issues.nodes) {
+                    for (const raw of candidates) {
                         const i = decodeIssueNode(raw);
-                        if (await hasHitlLabel(raw, config.hitlLabel))
+                        const labels = await fetchIssueLabelNames(raw);
+                        if (labels.includes(config.hitlLabel))
                             continue;
                         if (await hasActiveBlocker(raw))
                             continue;
@@ -327,6 +352,7 @@ export function createLinearGateway(config, limiter = null) {
                             identifier: i.identifier,
                             title: i.title,
                             description: i.description ?? "",
+                            labels,
                         });
                     }
                     return eligible;

package/dist/orchestrator.js CHANGED Viewed

@@ -5,9 +5,9 @@ import { detectBaseBranch, pruneStaleAgentBranch } from "./git.js";
 import { loadPolicy } from "./policy.js";
 import { flagHitl, handleProcessFailure } from "./hitl.js";
 import { runImplementLoop } from "./implement.js";
-import { formatPriorFeedback } from "./prompts.js";
+import { formatInRunReviewerFeedback, formatPriorFeedback, } from "./prompts.js";
 import { runReviewPass } from "./review.js";
-import { finalize } from "./finalize.js";
+import { finalize, formatRebaseConflictReason } from "./finalize.js";
 // Re-exports so existing callers (commands/run.ts) and tests
 // (orchestrator.test.ts) keep working without import churn. The
 // verdict parsers and the ADT now live alongside the phase code
@@ -104,6 +104,12 @@ export const drainQueue = (deps, opts = {}) => Effect.gen(function* () {
         // the processIssue span's attributes. Compute it inside the
         // span scope (so `annotateCurrentSpan` targets `processIssue`,
         // not `drainQueue`) and route afterwards.
+        //
+        // VA-387: annotate `runway.pr.url` on opened outcomes and
+        // `runway.hitl.reason` on HITL outcomes (both planned and
+        // failure-routed) so the detail pane can render the GitHub
+        // link / human-review reason without re-parsing the generic
+        // `runway.outcome.detail` string.
         const resolved = yield* Effect.gen(function* () {
             const processed = yield* processIssue(issue, runDeps).pipe(Effect.either);
             if (processed._tag === "Right") {
@@ -111,6 +117,9 @@ export const drainQueue = (deps, opts = {}) => Effect.gen(function* () {
                 yield* Effect.annotateCurrentSpan({
                     "runway.outcome.kind": result.kind,
                     "runway.outcome.detail": result.detail,
+                    ...(result.kind === "opened"
+                        ? { "runway.pr.url": result.detail }
+                        : { "runway.hitl.reason": result.detail }),
                 });
                 return { errored: false, outcome: result };
             }
@@ -123,12 +132,22 @@ export const drainQueue = (deps, opts = {}) => Effect.gen(function* () {
                 // from "crashed and routed to HITL" (kind=hitl,
                 // errored=true) on the dashboard row.
                 "runway.outcome.errored": true,
+                // VA-387: only "errored" failure outcomes land on HITL.
+                // "reverted" outcomes go back to Todo and never reach a
+                // human, so `runway.hitl.reason` would be misleading.
+                ...(failureOutcome.kind === "errored"
+                    ? { "runway.hitl.reason": failureOutcome.detail }
+                    : {}),
             });
             return { errored: true, outcome: failureOutcome };
         }).pipe(Effect.withSpan("processIssue", {
             attributes: {
                 "runway.issue.identifier": issue.identifier,
                 "runway.issue.id": issue.id,
+                "runway.issue.title": issue.title,
+                // OTel encodes string[] as arrayValue on the wire. The
+                // projector decodes it back via `attrMap`.
+                "runway.issue.labels": [...issue.labels],
                 "runway.branch": branch,
             },
         }), Effect.annotateLogs({
@@ -187,23 +206,85 @@ const processIssue = (issue, deps) => Effect.gen(function* () {
         : linear.fetchComments(issue.id).pipe(Effect.map((cs) => formatPriorFeedback(cs, commentAuthorAllowlist)), Effect.catchAll((err) => Effect.logWarning(`${issue.identifier}: fetchComments failed; proceeding with description-only context (${err.message ?? String(err)})`).pipe(Effect.as("")))));
     yield* linear.transition(issue.id, config.inProgressStatus);
     yield* linear.comment(issue.id, `Runway picked up this issue. Branch: \`${branch}\`.`);
-    // VA-366: if a prior attempt left an `agent/<id>` branch behind
-    // with zero commits ahead of base (typical of a startup-failure
-    // retry), delete it so sandcastle's worktree creation forks from
-    // current `baseBranch` HEAD. Preserves the branch when it carries
-    // real work. Best-effort — failures here don't abort the issue.
-    yield* pruneStaleAgentBranch(deps.cwd, deps.baseBranch, branch).pipe(Effect.catchAll((err) => Effect.logWarning(`${issue.identifier}: pruneStaleAgentBranch failed (continuing): ${err.message}`)));
-    const impl = yield* runImplementLoop(issue, { ...deps, priorFeedback }, branch);
-    if (impl.kind === "hitl") {
-        yield* flagHitl(issue, deps, impl.reason);
-        return { kind: "hitl", detail: impl.reason };
-    }
-    const review = yield* runReviewPass(issue, deps, branch);
-    if (review.kind === "hitl") {
-        yield* flagHitl(issue, deps, review.reason);
-        return { kind: "hitl", detail: review.reason };
+    // VA-366 + VA-417: keep the agent branch from carrying state
+    // forward across drains.
+    //   - VA-366: if a prior attempt left `agent/<id>` behind with no
+    //     commits (typical of a startup-failure retry), delete it.
+    //   - VA-417: if `agent/<id>` carries commits from a prior attempt
+    //     that review rejected, reset it to `origin/<baseBranch>` so
+    //     the impl agent doesn't observe the rejected diff and signal
+    //     `IMPL: DONE` without modification.
+    // The function fails ONLY with `AgentBranchResetTargetUnreachable`
+    // (origin/<base> AND local <base> both missing — env/config
+    // issue). `Effect.orDie` kills the drain so the operator fixes
+    // the env rather than re-trigger the no-op pattern; other git
+    // failures inside the function are already swallowed there.
+    yield* pruneStaleAgentBranch(deps.cwd, deps.baseBranch, branch).pipe(Effect.orDie);
+    // VA-418: in-run review-rejection retry loop. Each iteration runs
+    // impl, then review; on `rejected-retry` (and remaining budget),
+    // we append the rejection reason to `inRunRejections`, re-render
+    // the impl prompt with the full chain in the
+    // `{{IN_RUN_REVIEWER_FEEDBACK}}` slot, and try again. `attempt`
+    // counts the impl+review pairs we've launched; the budget is
+    // `1 + config.reviewRetries`, matching VA-414's pattern (default
+    // 1 means up to 2 total pairs per drain pickup). `0` disables the
+    // loop entirely: every rejection escalates immediately.
+    const retryBudget = Math.max(0, config.reviewRetries);
+    const inRunRejections = [];
+    let attempt = 0;
+    while (true) {
+        attempt += 1;
+        const impl = yield* runImplementLoop(issue, {
+            ...deps,
+            priorFeedback,
+            inRunReviewerFeedback: formatInRunReviewerFeedback(inRunRejections),
+        }, branch);
+        if (impl.kind === "hitl") {
+            yield* flagHitl(issue, deps, impl.reason);
+            return { kind: "hitl", detail: impl.reason };
+        }
+        const review = yield* runReviewPass(issue, deps, branch);
+        if (review.kind === "approved") {
+            // VA-419: finalize may report `rebase-conflict` when the base
+            // branch advanced during this drain and the post-review rebase
+            // hit a conflict. Route to HITL with the conflicted-file list
+            // — reviewer's APPROVED verdict is preserved in the message so
+            // the operator knows the diff was good before the conflict
+            // surfaced.
+            const finalized = yield* finalize(issue, deps, branch);
+            if (finalized.kind === "rebase-conflict") {
+                const reason = formatRebaseConflictReason(finalized);
+                yield* flagHitl(issue, deps, reason);
+                return { kind: "hitl", detail: reason };
+            }
+            return finalized;
+        }
+        if (review.kind === "hitl") {
+            // Crashed / truncated marker — distinct from a real rejection.
+            yield* flagHitl(issue, deps, review.reason);
+            return { kind: "hitl", detail: review.reason };
+        }
+        if (review.kind === "rejected-hitl") {
+            // Reviewer judged the rejection to need human input. Escalate
+            // immediately — no more impl attempts this drain.
+            const reason = `Sub-agent review rejected (needs human judgment): ${review.reason}`;
+            yield* flagHitl(issue, deps, reason);
+            return { kind: "hitl", detail: reason };
+        }
+        // rejected-retry: mechanically fixable. Hand the reason back to
+        // the impl agent on the next attempt, unless the retry budget is
+        // exhausted.
+        inRunRejections.push(review.reason);
+        if (attempt > retryBudget) {
+            // Budget exhausted. Escalate to HITL with a message that
+            // names the FINAL rejection reason plus the chain length so
+            // the operator can see how many attempts we burned through.
+            const reason = `Ran out of review retries (${attempt} attempt${attempt === 1 ? "" : "s"}); last rejection: ${review.reason}`;
+            yield* flagHitl(issue, deps, reason);
+            return { kind: "hitl", detail: reason };
+        }
+        yield* Effect.logInfo(`${issue.identifier}: review rejected-retry; retrying impl with reviewer feedback (attempt ${attempt + 1} of ${retryBudget + 1})`);
     }
-    return yield* finalize(issue, deps, branch);
 });
 /**
  * VA-355: render a per-issue verdict trail at the end of the drain so

package/dist/prompts.js CHANGED Viewed

@@ -55,6 +55,12 @@ function implementVars(args) {
         ISSUE_DESCRIPTION: args.issue.description || "(no description)",
         PREVIOUS_ITERATIONS: args.previousIterations,
         PRIOR_REVIEW_FEEDBACK: args.priorReviewFeedback,
+        // VA-418: empty string when the orchestrator has no in-run
+        // rejection to surface (the common case — first attempt, or a
+        // run with retries disabled). The `{{IN_RUN_REVIEWER_FEEDBACK}}`
+        // slot expands to empty and the section header disappears from
+        // the rendered prompt.
+        IN_RUN_REVIEWER_FEEDBACK: args.inRunReviewerFeedback ?? "",
         POLICY_FORBIDDEN_BULLET: renderForbiddenPathsBullet(args.policy),
         // VA-417: fall back to "main" if the caller didn't pass one, so
         // older test fixtures keep working. Production always passes the
@@ -132,6 +138,40 @@ export function formatPriorFeedback(comments, allowlist) {
         "",
     ].join("\n");
 }
+/**
+ * VA-418: format the reviewer's in-run rejection text into the block
+ * the implement prompt renders into `{{IN_RUN_REVIEWER_FEEDBACK}}`.
+ * Higher-trust framing than VA-383's cross-drain feedback — this is
+ * the reviewer's verdict on the diff the agent JUST produced in this
+ * drain, not stale guidance from a prior runway invocation.
+ *
+ * `rejections` is the chronological list of rejection reasons from
+ * every prior review pass in the current drain. The most recent
+ * rejection is the load-bearing one; earlier rejections are included
+ * so the agent can see what it has already tried + been told to fix.
+ *
+ * Returns the empty string when there are no rejections to surface —
+ * the slot expands to empty and the section disappears from the
+ * rendered prompt.
+ */
+export function formatInRunReviewerFeedback(rejections) {
+    if (rejections.length === 0)
+        return "";
+    const numbered = rejections.map((r, i) => `${i + 1}. ${r.trim()}`);
+    return [
+        "# Reviewer feedback from this run",
+        "",
+        "The previous iteration of this drain produced commits that review",
+        "rejected. Every blocker below is from review of YOUR work this run —",
+        "the reviewer judged each fix to be mechanical (no human judgment",
+        "required). Address every blocker before signaling `IMPL: DONE` again.",
+        "",
+        "Rejections so far this drain (most recent last):",
+        "",
+        numbered.join("\n"),
+        "",
+    ].join("\n");
+}
 /**
  * VA-352 (absorbed from policy.ts in VA-361): render the bullet
  * sentence the impl prompt shows the agent. Stable formatting so a