@valescoagency/runway 0.15.0 → 0.16.0

package/dist/dashboard/projector.js

@@ -149,15 +149,182 @@ function strArrayAttr(v) {
  */
 export const DRAIN_STARTED_LOG = "drain.started";
 /**
- * VA-465: log body strings the shepherd loop emits at three points.
- * Each carries structured attributes the projector reads to update
- * the `shepherding_prs` table. Kept in lock-step with `shepherd.ts`'s
- * `Effect.logInfo` call sites — drift between the two means the
- * sub-card stops rendering for the affected lifecycle event.
+ * VA-474: log body strings the planner daemon emits for its six
+ * event types (ADR 0004 § Writer model). Kept in lock-step with the
+ * planner's `Effect.logInfo` call sites — drift between projector
+ * and planner means events stop projecting into the read-model.
  */
-export const SHEPHERD_ITERATION_START_LOG = "shepherd.iteration.start";
-export const SHEPHERD_ITERATION_END_LOG = "shepherd.iteration.end";
-export const SHEPHERD_ENDED_LOG = "shepherd.ended";
+export const PLANNER_RECOMMENDATION_PROPOSED_LOG = "planner.recommendation.proposed";
+export const PLANNER_RECOMMENDATION_ACCEPTED_LOG = "planner.recommendation.accepted";
+export const PLANNER_RECOMMENDATION_REJECTED_LOG = "planner.recommendation.rejected";
+export const PLANNER_ACTION_STARTED_LOG = "planner.action.started";
+export const PLANNER_ACTION_COMPLETED_LOG = "planner.action.completed";
+export const PLANNER_ACTION_FAILED_LOG = "planner.action.failed";
+/**
+ * VA-481: emitted by the planner's HTTP PUT /planner/capabilities/:capability
+ * handler when an operator (or the planner's auto-promotion logic)
+ * changes a capability's mode (manual / suggest / auto). The dashboard
+ * projects each event into the `planner_capability_modes` table; the
+ * planner reads the table on every tick so toggles take effect on
+ * the next iteration without a daemon restart.
+ */
+export const PLANNER_CAPABILITY_MODE_CHANGED_LOG = "planner.capability.mode_changed";
+export const PLANNER_CAPABILITY_MODES = new Set([
+    "manual",
+    "suggest",
+    "auto",
+]);
+const PLANNER_CAPABILITIES = new Set([
+    "queue-selection",
+    "shepherd-mergeability",
+    "shepherd-ci",
+    "shepherd-reviewer",
+]);
+/**
+ * VA-474: scan an OTLP logs payload for the six planner-event
+ * markers. Records that fail validation (missing required
+ * attribute, unknown capability, unparseable `evidence`) are
+ * dropped — the projector never crashes on a bad payload, but it
+ * also never fabricates fields the emitter didn't send.
+ */
+export function extractPlannerMarkers(payload) {
+    const out = [];
+    for (const rl of payload.resourceLogs ?? []) {
+        for (const sl of rl.scopeLogs ?? []) {
+            for (const rec of sl.logRecords ?? []) {
+                const body = rec.body?.stringValue;
+                if (!body || !body.startsWith("planner."))
+                    continue;
+                const ts = rec.timeUnixNano ?? rec.observedTimeUnixNano;
+                if (!ts)
+                    continue;
+                const attrs = attributesToStringMap(rec.attributes);
+                if (body === PLANNER_RECOMMENDATION_PROPOSED_LOG) {
+                    const recommendationId = attrs.recommendationId;
+                    const capability = attrs.capability;
+                    const target = attrs.target;
+                    const summary = attrs.summary;
+                    if (!recommendationId ||
+                        !capability ||
+                        !PLANNER_CAPABILITIES.has(capability) ||
+                        !target ||
+                        !summary) {
+                        continue;
+                    }
+                    let evidence = {};
+                    const rawEvidence = attrs.evidence;
+                    if (rawEvidence) {
+                        try {
+                            const parsed = JSON.parse(rawEvidence);
+                            if (parsed &&
+                                typeof parsed === "object" &&
+                                !Array.isArray(parsed)) {
+                                evidence = parsed;
+                            }
+                        }
+                        catch {
+                            // Malformed evidence JSON is non-fatal — emit with {}
+                            // so the recommendation still lands.
+                        }
+                    }
+                    out.push({
+                        kind: "recommendation.proposed",
+                        recommendationId,
+                        capability: capability,
+                        target,
+                        summary,
+                        evidence,
+                        autoApproveEligible: attrs.autoApproveEligible === "true",
+                        timestampUnixNano: ts,
+                    });
+                }
+                else if (body === PLANNER_RECOMMENDATION_ACCEPTED_LOG ||
+                    body === PLANNER_RECOMMENDATION_REJECTED_LOG) {
+                    const recommendationId = attrs.recommendationId;
+                    const source = attrs.source;
+                    if (!recommendationId ||
+                        (source !== "operator" && source !== "auto")) {
+                        continue;
+                    }
+                    const status = body === PLANNER_RECOMMENDATION_ACCEPTED_LOG
+                        ? "accepted"
+                        : "rejected";
+                    out.push({
+                        kind: status === "accepted"
+                            ? "recommendation.accepted"
+                            : "recommendation.rejected",
+                        recommendationId,
+                        status,
+                        source,
+                        reason: attrs.reason ?? null,
+                        timestampUnixNano: ts,
+                    });
+                }
+                else if (body === PLANNER_ACTION_STARTED_LOG) {
+                    const actionId = attrs.actionId;
+                    const capability = attrs.capability;
+                    const target = attrs.target;
+                    if (!actionId ||
+                        !capability ||
+                        !PLANNER_CAPABILITIES.has(capability) ||
+                        !target) {
+                        continue;
+                    }
+                    out.push({
+                        kind: "action.started",
+                        actionId,
+                        recommendationId: attrs.recommendationId ?? null,
+                        capability: capability,
+                        target,
+                        timestampUnixNano: ts,
+                    });
+                }
+                else if (body === PLANNER_ACTION_COMPLETED_LOG) {
+                    const actionId = attrs.actionId;
+                    const outcome = attrs.outcome;
+                    if (!actionId || !outcome)
+                        continue;
+                    out.push({
+                        kind: "action.completed",
+                        actionId,
+                        outcome,
+                        timestampUnixNano: ts,
+                    });
+                }
+                else if (body === PLANNER_ACTION_FAILED_LOG) {
+                    const actionId = attrs.actionId;
+                    const error = attrs.error;
+                    if (!actionId || !error)
+                        continue;
+                    out.push({
+                        kind: "action.failed",
+                        actionId,
+                        error,
+                        timestampUnixNano: ts,
+                    });
+                }
+                else if (body === PLANNER_CAPABILITY_MODE_CHANGED_LOG) {
+                    const capability = attrs.capability;
+                    const mode = attrs.mode;
+                    if (!capability ||
+                        !PLANNER_CAPABILITIES.has(capability) ||
+                        !mode ||
+                        !PLANNER_CAPABILITY_MODES.has(mode)) {
+                        continue;
+                    }
+                    out.push({
+                        kind: "capability.mode_changed",
+                        capability: capability,
+                        mode: mode,
+                        updatedBy: attrs.updatedBy ?? "operator",
+                        timestampUnixNano: ts,
+                    });
+                }
+            }
+        }
+    }
+    return out;
+}
 /**
  * VA-455: scan an OTLP logs payload for `drain.started` markers.
  * Each match becomes an `ActiveDrainMarker` carrying the drain's
@@ -198,86 +365,6 @@ export function extractActiveDrainMarkers(payload) {
     }
     return out;
 }
-/**
- * VA-465: scan an OTLP logs payload for shepherd lifecycle markers.
- * Three body strings produce three marker kinds; each is tagged so
- * the server can dispatch to the right storage method. Records
- * missing trace_id, a recognised body, or a timestamp are dropped —
- * we won't fabricate any of those.
- *
- * Attribute reading is lenient: the gateway encodes numbers as
- * strings via OTLP's `stringValue`, so we re-parse with
- * `Number.parseInt`. Missing attributes get sensible defaults
- * (e.g., empty subscription, null max_iterations) rather than
- * causing the marker to be dropped — a partial marker is still
- * useful for the dashboard.
- */
-export function extractShepherdMarkers(payload) {
-    const out = [];
-    for (const rl of payload.resourceLogs ?? []) {
-        for (const sl of rl.scopeLogs ?? []) {
-            for (const rec of sl.logRecords ?? []) {
-                const body = rec.body?.stringValue;
-                if (body !== SHEPHERD_ITERATION_START_LOG &&
-                    body !== SHEPHERD_ITERATION_END_LOG &&
-                    body !== SHEPHERD_ENDED_LOG) {
-                    continue;
-                }
-                const traceId = rec.traceId?.trim();
-                if (!traceId)
-                    continue;
-                const ts = rec.timeUnixNano ?? rec.observedTimeUnixNano;
-                if (!ts)
-                    continue;
-                const attrs = attributesToStringMap(rec.attributes);
-                const prNumber = Number.parseInt(attrs.pr ?? "", 10);
-                if (!Number.isFinite(prNumber))
-                    continue;
-                if (body === SHEPHERD_ITERATION_START_LOG) {
-                    const iteration = Number.parseInt(attrs.iteration ?? "", 10);
-                    if (!Number.isFinite(iteration))
-                        continue;
-                    const maxIter = Number.parseInt(attrs.maxIterations ?? "", 10);
-                    out.push({
-                        kind: "iteration.start",
-                        traceId,
-                        prNumber,
-                        subscription: attrs.subscription ?? "",
-                        iteration,
-                        maxIterations: Number.isFinite(maxIter) ? maxIter : null,
-                        description: attrs.description ?? "",
-                        timestampUnixNano: ts,
-                    });
-                }
-                else if (body === SHEPHERD_ITERATION_END_LOG) {
-                    const outcome = attrs.outcome === "hitl" ? "hitl" : "fixed";
-                    out.push({
-                        kind: "iteration.end",
-                        traceId,
-                        prNumber,
-                        outcome,
-                        detail: attrs.detail ?? "",
-                        timestampUnixNano: ts,
-                    });
-                }
-                else {
-                    const raw = attrs.outcome;
-                    const outcome = raw === "merged" || raw === "ready" || raw === "hitl"
-                        ? raw
-                        : "hitl"; // Conservative fallback — terminal hitl is the safe default.
-                    out.push({
-                        kind: "ended",
-                        traceId,
-                        prNumber,
-                        outcome,
-                        timestampUnixNano: ts,
-                    });
-                }
-            }
-        }
-    }
-    return out;
-}
 /**
  * VA-388: project an OTLP logs payload into `LogRecordRow`s. Records
  * without a trace_id are dropped — every Effect log emitted under

package/dist/dashboard/server.js

@@ -1,19 +1,19 @@
 import { createServer } from "node:http";
 import { createLinearAdapter, startLinearSync, } from "./linear-sync.js";
 import { createEventBus } from "./events.js";
-import { extractActiveDrainMarkers, extractShepherdMarkers, projectLogs, projectPayload, } from "./projector.js";
+import { extractActiveDrainMarkers, extractPlannerMarkers, projectLogs, projectPayload, } from "./projector.js";
 import { createStorage, } from "./storage.js";
-import { META_REVIEW_PAGE_SIZE, renderDetailView, renderIssueProcessRows, renderListView, renderLogsSection, renderMetaReviewDetailView, renderMetaReviewListView, } from "./views.js";
+import { META_REVIEW_PAGE_SIZE, renderDetailView, renderIssueProcessRows, renderListView, renderLogsSection, renderMetaReviewDetailView, renderMetaReviewListView, renderPlannerPanel, } 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",
-    // VA-460: shepherd span — emitted by runShepherdPass when
-    // `config.shepherdEnabled=true`. Surfaced alongside review so the
-    // operator sees post-finalize loop time on the timeline. Missing
-    // for any issue process whose drain ran without the feature gate.
+    // VA-460 → VA-482: legacy `shepherd` span surfaced inline by the
+    // retired post-finalize loop. Kept in the allowlist so historical
+    // traces (issue_processes rows written before VA-482) still
+    // render their fourth phase row; new traces never emit it.
     "shepherd",
 ];
 const ISSUE_DETAIL_RE = /^\/issue\/([^/?#]+)\/([^/?#]+)\/?$/;
@@ -152,6 +152,35 @@ async function handle(req, res, storage, linearEnabled, linearWorkspace, events)
         handleAggregates(res, storage);
         return;
     }
+    // VA-481: planner panel — recommendations + capability modes.
+    if (method === "GET" && (url === "/planner" || url.startsWith("/planner?"))) {
+        handlePlannerPanel(res, storage);
+        return;
+    }
+    // VA-481: proxy routes that forward to the Tailscale-gated planner
+    // HTTP API. Browser forms POST to the dashboard's same-origin path;
+    // the dashboard server-side forwards to RUNWAY_PLANNER_BASE_URL so
+    // the planner's same-origin CORS guard is satisfied. The
+    // dashboard never inspects request bodies beyond passthrough — the
+    // planner remains the source of truth.
+    const pathOnly = url.split("?")[0] ?? "";
+    if (method === "POST") {
+        const acceptMatch = pathOnly.match(/^\/planner-actions\/recommendations\/([^/]+)\/accept$/);
+        if (acceptMatch) {
+            await handlePlannerProxy(req, res, `/planner/recommendations/${encodeURIComponent(acceptMatch[1] ?? "")}/accept`, "POST");
+            return;
+        }
+        const rejectMatch = pathOnly.match(/^\/planner-actions\/recommendations\/([^/]+)\/reject$/);
+        if (rejectMatch) {
+            await handlePlannerProxy(req, res, `/planner/recommendations/${encodeURIComponent(rejectMatch[1] ?? "")}/reject`, "POST");
+            return;
+        }
+        const capMatch = pathOnly.match(/^\/planner-actions\/capabilities\/([a-z-]+)$/i);
+        if (capMatch) {
+            await handlePlannerProxy(req, res, `/planner/capabilities/${encodeURIComponent(capMatch[1] ?? "")}`, "PUT");
+            return;
+        }
+    }
     if (method === "GET" && url === "/healthz") {
         res.writeHead(200, { "content-type": "text/plain" });
         res.end("ok");
@@ -256,37 +285,69 @@ async function handleOtlpLogs(req, res, storage, events) {
     for (const m of extractActiveDrainMarkers(payload)) {
         storage.markDrainActive(m);
     }
-    // VA-465: shepherd lifecycle markers drive the per-PR sub-card.
-    // Three log bodies map to three storage methods — see
-    // `extractShepherdMarkers` for the body strings.
-    for (const m of extractShepherdMarkers(payload)) {
-        if (m.kind === "iteration.start") {
-            storage.markShepherdIterationStart({
-                traceId: m.traceId,
-                prNumber: m.prNumber,
-                subscription: m.subscription,
-                iteration: m.iteration,
-                maxIterations: m.maxIterations,
-                description: m.description,
-                timestampUnixNano: m.timestampUnixNano,
-            });
-        }
-        else if (m.kind === "iteration.end") {
-            storage.markShepherdIterationEnd({
-                traceId: m.traceId,
-                prNumber: m.prNumber,
-                outcome: m.outcome,
-                detail: m.detail,
-                timestampUnixNano: m.timestampUnixNano,
-            });
-        }
-        else {
-            storage.markShepherdEnded({
-                traceId: m.traceId,
-                prNumber: m.prNumber,
-                outcome: m.outcome,
-                timestampUnixNano: m.timestampUnixNano,
-            });
+    // VA-482: the inline shepherd's three lifecycle markers
+    // (shepherd.iteration.start / iteration.end / ended) are gone —
+    // the planner emits `planner.action.*` for the same shape of work
+    // via the capability dispatchers (VA-477..479).
+    // VA-474: planner event markers — six log bodies cover the
+    // recommendation lifecycle (proposed / accepted / rejected) and
+    // the action lifecycle (started / completed / failed). All five
+    // storage writers are idempotent on their primary keys; an OTLP
+    // retry or duplicate delivery is a no-op.
+    for (const m of extractPlannerMarkers(payload)) {
+        switch (m.kind) {
+            case "recommendation.proposed":
+                storage.recordPlannerRecommendationProposed({
+                    recommendationId: m.recommendationId,
+                    capability: m.capability,
+                    target: m.target,
+                    summary: m.summary,
+                    evidence: m.evidence,
+                    autoApproveEligible: m.autoApproveEligible,
+                    timestampUnixNano: m.timestampUnixNano,
+                });
+                break;
+            case "recommendation.accepted":
+            case "recommendation.rejected":
+                storage.recordPlannerRecommendationDecision({
+                    recommendationId: m.recommendationId,
+                    status: m.status,
+                    source: m.source,
+                    reason: m.reason,
+                    timestampUnixNano: m.timestampUnixNano,
+                });
+                break;
+            case "action.started":
+                storage.recordPlannerActionStarted({
+                    actionId: m.actionId,
+                    recommendationId: m.recommendationId,
+                    capability: m.capability,
+                    target: m.target,
+                    timestampUnixNano: m.timestampUnixNano,
+                });
+                break;
+            case "action.completed":
+                storage.recordPlannerActionCompleted({
+                    actionId: m.actionId,
+                    outcome: m.outcome,
+                    timestampUnixNano: m.timestampUnixNano,
+                });
+                break;
+            case "action.failed":
+                storage.recordPlannerActionFailed({
+                    actionId: m.actionId,
+                    error: m.error,
+                    timestampUnixNano: m.timestampUnixNano,
+                });
+                break;
+            case "capability.mode_changed":
+                storage.recordPlannerCapabilityModeChange({
+                    capability: m.capability,
+                    mode: m.mode,
+                    updatedBy: m.updatedBy,
+                    timestampUnixNano: m.timestampUnixNano,
+                });
+                break;
         }
     }
     for (const r of projectLogs(payload)) {
@@ -422,19 +483,14 @@ function handleListView(req, res, storage, linearEnabled, linearWorkspace) {
     // `drains` row). `null` becomes the "Idle — no active drain"
     // state in views.
     const activeDrain = storage.getActiveDrain();
-    // VA-465: when a drain is active, surface its in-flight shepherding
-    // PRs as a sub-strip under the drain strip. Idle drain → no
-    // shepherd rows to query.
-    const activeShepherding = activeDrain
-        ? storage.getActiveShepherding(activeDrain.traceId)
-        : [];
+    // VA-465 → VA-482: the inline shepherd sub-strip is retired; per-PR
+    // state now lives in the planner panel at `/planner`.
     const html = renderListView({
         rows,
         linearEnabled,
         todoQueue,
         snapshotsByIdentifier,
         activeDrain,
-        activeShepherding,
         filterState,
         recentDrains,
         isFiltered: isFilteredState(filterState),
@@ -585,6 +641,132 @@ function handleAggregates(res, storage) {
     res.writeHead(200, { "content-type": "application/json" });
     res.end(JSON.stringify({ view: "evaluator_aggregates_v1", rows }));
 }
+const KNOWN_PLANNER_CAPABILITIES = [
+    { capability: "queue-selection" },
+    { capability: "shepherd-mergeability" },
+    { capability: "shepherd-ci" },
+    { capability: "shepherd-reviewer" },
+];
+/**
+ * VA-481: forward an operator-initiated POST/PUT from the dashboard
+ * UI to the planner's HTTP API. The dashboard runs as a separate
+ * process; making the call server-side preserves the planner's
+ * same-origin CORS guard without an allowlist. Body is parsed from
+ * the operator's HTML form (urlencoded `reason=...` for reject,
+ * `mode=...` for capability toggle) and re-serialized as JSON for
+ * the planner. On success/202 from the planner, the dashboard 303s
+ * back to `/planner` so the operator sees the refreshed list.
+ */
+async function handlePlannerProxy(req, res, plannerPath, method) {
+    const baseUrl = process.env.RUNWAY_PLANNER_BASE_URL ?? "http://127.0.0.1:3002";
+    // Parse the form body — content-type may be application/json (api)
+    // or application/x-www-form-urlencoded (form submit).
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(chunk);
+        // Match the planner's 64 KiB cap so a giant body doesn't OOM.
+        const total = chunks.reduce((s, c) => s + c.length, 0);
+        if (total > 64 * 1024) {
+            res.writeHead(413, { "content-type": "application/json" });
+            res.end(JSON.stringify({ error: { code: "payload_too_large", message: "body too large" } }));
+            return;
+        }
+    }
+    const raw = Buffer.concat(chunks).toString("utf8");
+    const ct = String(req.headers["content-type"] ?? "").toLowerCase();
+    let bodyJson;
+    if (ct.includes("application/x-www-form-urlencoded")) {
+        const params = new URLSearchParams(raw);
+        const obj = {};
+        for (const [k, v] of params.entries()) {
+            if (v.length > 0)
+                obj[k] = v;
+        }
+        bodyJson = JSON.stringify(obj);
+    }
+    else if (raw.length === 0) {
+        bodyJson = "{}";
+    }
+    else {
+        bodyJson = raw; // assume JSON; let planner validate
+    }
+    let upstream;
+    try {
+        upstream = await fetch(`${baseUrl}${plannerPath}`, {
+            method,
+            headers: { "content-type": "application/json" },
+            body: bodyJson,
+        });
+    }
+    catch (err) {
+        res.writeHead(502, { "content-type": "application/json" });
+        res.end(JSON.stringify({
+            error: {
+                code: "planner_unreachable",
+                message: err instanceof Error ? err.message : String(err),
+            },
+        }));
+        return;
+    }
+    // Form submissions expect a 303 redirect back to the panel. JSON
+    // clients (curl / fetch from a script) get the planner's status
+    // mirrored verbatim. The dashboard distinguishes via the
+    // `Accept` header — browser form posts default to text/html.
+    const accept = String(req.headers.accept ?? "").toLowerCase();
+    const wantsRedirect = accept.includes("text/html") &&
+        upstream.status >= 200 &&
+        upstream.status < 400;
+    if (wantsRedirect) {
+        res.writeHead(303, { Location: "/planner" });
+        res.end();
+        return;
+    }
+    const upstreamBody = await upstream.text();
+    res.writeHead(upstream.status, {
+        "content-type": upstream.headers.get("content-type") ?? "application/json",
+    });
+    res.end(upstreamBody);
+}
+function handlePlannerPanel(res, storage) {
+    const explicit = storage.listPlannerCapabilityModes();
+    const byCap = new Map(explicit.map((r) => [r.capability, r]));
+    const capabilities = KNOWN_PLANNER_CAPABILITIES.map((c) => {
+        const row = byCap.get(c.capability);
+        return row
+            ? {
+                capability: row.capability,
+                mode: row.mode,
+                updatedUnixNano: row.updatedUnixNano,
+                updatedBy: row.updatedBy,
+            }
+            : {
+                capability: c.capability,
+                mode: "suggest",
+                updatedUnixNano: null,
+                updatedBy: null,
+            };
+    });
+    const recommendations = storage
+        .getRecentPlannerRecommendations(20)
+        .map((r) => ({
+        recommendationId: r.recommendationId,
+        capability: r.capability,
+        target: r.target,
+        summary: r.summary,
+        status: r.status,
+        autoApproveEligible: r.autoApproveEligible,
+        proposedUnixNano: r.proposedUnixNano,
+        decidedBy: r.decidedBy,
+    }));
+    const plannerBaseUrl = process.env.RUNWAY_PLANNER_BASE_URL ?? "http://127.0.0.1:3002";
+    const html = renderPlannerPanel({
+        capabilities,
+        recommendations,
+        plannerBaseUrl,
+    });
+    res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+    res.end(html);
+}
 /**
  * VA-407: GET `/meta-reviews` — paginated list view of meta_reviews
  * rows. `?kind=<kind>` narrows to one kind; `?page=N` is 1-based and