@dev-loops/core 0.6.0 → 0.7.1

package/src/loop/queue-driver.mjs

@@ -9,6 +9,7 @@ import {
   transitionEntry,
   snapshotEntry,
   nextReadyEntry,
+  findEntry,
   allDone,
   RECOVERABLE_FAILURES,
   appendBugIssue,
@@ -19,7 +20,13 @@ import {
   boardColumnForLoopState,
   loadStateColumnMap,
 } from "./queue-board-sync.mjs";
-import { resolveNextUpOrder } from "./queue-board-ordering.mjs";
+import {
+  resolveNextUpOrder,
+  REASON_NEXT_UP_EMPTY,
+  REASON_BOARD_QUERY_ERROR,
+  REASON_NEXT_UP_TARGET_MISSING_LOCALLY,
+  EMPTY_NEXT_UP_MESSAGE,
+} from "./queue-board-ordering.mjs";
 
 export const DEFAULT_QUEUE_DRIVER_OPTIONS = {
   mergeAuthorized: false,
@@ -92,23 +99,88 @@ export async function runQueue(repoRoot, repo, options = {}) {
   // (e.g. a configured "Ready for Review") still syncs. (#793 round-1 #1)
   const lastSyncedColumn = new Map();
 
-  // Optional board-aware ordering: fetch Next Up order before processing.
-  // Fail-open: if the board is unreachable, orderHint stays empty and the
-  // driver falls back to the existing queue order.
-  const ordering = opts.useBoardOrdering !== false && !allDone(queue)
+  // Next Up is the NORMATIVE, fail-closed pickup source (#1091). When a board is
+  // configured, the driver picks ONLY entries whose target is in Next Up, by
+  // POSITION ascending; entries absent from Next Up are never auto-picked. It
+  // NEVER falls back to Backlog or to the non-board local queue order.
+  //
+  // Single-issue/PR runs do not reach this gating at all — they run via the
+  // dev-loop routing path, not the queue driver — so an explicit --issue/--pr
+  // target is inherently unaffected by Next Up.
+  const ordering = !allDone(queue)
     ? await resolveNextUpOrder(repo, repoRoot, opts.env ?? process.env, opts.queueBoardSyncDependencies ?? {})
-    : { ok: true, order: [], reason: "board ordering disabled or queue idle" };
-  const orderHint = ordering.ok ? ordering.order : [];
+    : { ok: true, configured: false, order: [], reason: "queue idle" };
+
+  // (b) Board-query ERROR → surface it and stop. Do NOT fall back to Backlog
+  // or local order (fail-closed). Distinct from an empty Next Up below.
+  if (ordering.ok === false) {
+    return {
+      ok: false,
+      stopped: true,
+      reason: REASON_BOARD_QUERY_ERROR,
+      message: `Next Up query failed (${ordering.reason}); refusing to fall back to Backlog/local order`,
+      error: ordering.reason ?? "board query failed",
+      results: [],
+      queue,
+      ordering,
+    };
+  }
+
+  // Board-gated only when a board is configured.
+  const boardGated = ordering.configured === true;
+  const orderHint = ordering.order;
+  const allowedTargets = boardGated ? new Set(orderHint) : null;
+
+  // (a) Empty Next Up (successful query, zero items) → fail CLOSED: idle/stop
+  // with an actionable, machine-readable outcome. Never pull from Backlog.
+  if (boardGated && orderHint.length === 0) {
+    return {
+      ok: true,
+      idle: true,
+      reason: REASON_NEXT_UP_EMPTY,
+      message: EMPTY_NEXT_UP_MESSAGE,
+      results: [],
+      queue,
+      ordering,
+    };
+  }
+
+  // (a2) Next Up resolved one or more targets that have NO matching local queue
+  // entry (membership reconcile not run/persisted, or the board changed between
+  // reconcile and this query). Filtering them out would return a silent empty
+  // idle while real Next Up work goes undispatched — so fail CLOSED with an
+  // actionable stop instead. Distinct from the genuine empty-Next-Up idle above.
+  // Never pull from Backlog. (#1091)
+  if (boardGated) {
+    const missingTargets = orderHint.filter((t) => !findEntry(queue, t));
+    if (missingTargets.length > 0) {
+      return {
+        ok: false,
+        stopped: true,
+        reason: REASON_NEXT_UP_TARGET_MISSING_LOCALLY,
+        missingTargets,
+        message:
+          "Next Up contains items with no local queue entry — run membership reconcile / re-add them",
+        results: [],
+        queue,
+        ordering,
+      };
+    }
+  }
 
   let autoFiledCount = 0;
   const results = [];
   let incomplete = false;
 
   while (!allDone(queue)) {
-    const entry = nextReadyEntry(queue, opts.reDispatchMaxRetries, orderHint);
+    const entry = nextReadyEntry(queue, opts.reDispatchMaxRetries, orderHint, allowedTargets);
     if (!entry) {
+      // When board-gated, entries absent from Next Up are intentionally NOT
+      // picked (and are not "blocked by deps") — only unfinished Next Up members
+      // count toward an incomplete verdict.
       const remaining = queue.entries.filter(
         (e) => e.status !== "done" && e.status !== "blocked" && e.status !== "failed"
+             && (!allowedTargets || allowedTargets.has(e.target))
       );
       if (remaining.length > 0) {
         incomplete = true;

package/src/loop/queue-state.mjs

@@ -183,9 +183,20 @@ function applyOrderHint(ordered, orderHint) {
   return [...inHint, ...rest];
 }
 
-export function nextReadyEntry(queue, maxRetries = 1, orderHint = []) {
+/**
+ * Pick the next ready entry.
+ *
+ * @param {object} queue
+ * @param {number} maxRetries
+ * @param {number[]} orderHint - preferred order (targets sorted to the front).
+ * @param {Set<number>|null} allowedTargets - when non-null, ONLY entries whose
+ *   target is in this set are eligible. Used for board-gated (Next Up)
+ *   selection (#1091): entries absent from Next Up are never auto-picked.
+ */
+export function nextReadyEntry(queue, maxRetries = 1, orderHint = [], allowedTargets = null) {
   const ordered = topologicalOrder(queue.entries);
-  const sorted = applyOrderHint(ordered, orderHint);
+  const restricted = allowedTargets ? ordered.filter((e) => allowedTargets.has(e.target)) : ordered;
+  const sorted = applyOrderHint(restricted, orderHint);
   for (const entry of sorted) {
     if (entry.status === "queued" && entryDependenciesSatisfied(queue, entry)) {
       return entry;

package/bin/capture-deep-persona-signals.mjs

@@ -1,143 +0,0 @@
-#!/usr/bin/env node
-import { mkdir, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { parseReviewThreads, readInput, parseJsonText, formatCliError } from "../src/github/review-threads.mjs";
-import { extractDeepPersonaSignals } from "../src/debt/deep-persona-signals.mjs";
-
-export const USAGE = [
-  "Usage: capture-deep-persona-signals.mjs --input <path> --pr-number <n> --pr-url <url> [--output-dir <path>]",
-  "",
-  "Arguments:",
-  "  --input <path>        Path to normalized review-thread JSON (required)",
-  "  --pr-number <n>       PR number for metadata (required)",
-  "  --pr-url <url>        PR URL for metadata (required)",
-  "  --output-dir <path>   Output directory for emitted artifact (default: .pi/debt/signals/)",
-].join("\n");
-
-/**
- * Parse CLI arguments for the capture-deep-persona-signals CLI.
- *
- * @param {string[]} argv - Argument list (e.g. process.argv.slice(2))
- * @returns {{ inputPath: string, prNumber: string, prUrl: string, outputDir: string }}
- */
-export function parseArgs(argv) {
-  const args = [...argv];
-  const options = {
-    inputPath: undefined,
-    prNumber: undefined,
-    prUrl: undefined,
-    outputDir: ".pi/debt/signals",
-  };
-
-  while (args.length > 0) {
-    const token = args.shift();
-
-    switch (token) {
-      case "--input": {
-        const value = args.shift();
-        if (typeof value !== "string" || value.length === 0 || value.startsWith("--")) {
-          throw Object.assign(new Error("Missing value for --input"), { usage: USAGE });
-        }
-        options.inputPath = value;
-        break;
-      }
-      case "--pr-number": {
-        const value = args.shift();
-        if (typeof value !== "string" || value.length === 0 || value.startsWith("--")) {
-          throw Object.assign(new Error("Missing value for --pr-number"), { usage: USAGE });
-        }
-        if (!/^\d+$/.test(value)) {
-          throw Object.assign(new Error(`--pr-number must be a positive integer, got: ${value}`), { usage: USAGE });
-        }
-        options.prNumber = value;
-        break;
-      }
-      case "--pr-url": {
-        const value = args.shift();
-        if (typeof value !== "string" || value.length === 0 || value.startsWith("--")) {
-          throw Object.assign(new Error("Missing value for --pr-url"), { usage: USAGE });
-        }
-        options.prUrl = value;
-        break;
-      }
-      case "--output-dir": {
-        const value = args.shift();
-        if (typeof value !== "string" || value.length === 0 || value.startsWith("--")) {
-          throw Object.assign(new Error("Missing value for --output-dir"), { usage: USAGE });
-        }
-        options.outputDir = value;
-        break;
-      }
-      default:
-        throw Object.assign(new Error(`Unknown argument: ${token}`), { usage: USAGE });
-    }
-  }
-
-  if (!options.inputPath) {
-    throw Object.assign(new Error("--input is required"), { usage: USAGE });
-  }
-  if (!options.prNumber) {
-    throw Object.assign(new Error("--pr-number is required"), { usage: USAGE });
-  }
-  if (!options.prUrl) {
-    throw Object.assign(new Error("--pr-url is required"), { usage: USAGE });
-  }
-
-  return /** @type {{ inputPath: string, prNumber: string, prUrl: string, outputDir: string }} */ (options);
-}
-
-/**
- * Generate the output filename.
- * @param {string} prNumber
- * @returns {string}
- */
-export function outputFilename(prNumber) {
-  const ts = new Date().toISOString().replace(/[:.]/g, "-");
-  return `deep-persona-signals-${prNumber}-${ts}.json`;
-}
-
-export async function run(argv = process.argv.slice(2)) {
-  const options = parseArgs(argv);
-
-  // Read and parse the review-thread input
-  const rawText = await readInput({ inputPath: options.inputPath });
-  const parsed = parseReviewThreads(parseJsonText(rawText));
-
-  // Extract deep-persona signals
-  const signals = extractDeepPersonaSignals(parsed, {
-    prNumber: options.prNumber,
-    prUrl: options.prUrl,
-  });
-
-  // Build artifact envelope
-  const artifact = {
-    version: 1,
-    generatedAt: new Date().toISOString(),
-    prNumber: Number(options.prNumber),
-    prUrl: options.prUrl,
-    source: "pr_review_deep_persona",
-    signalCount: signals.length,
-    signals,
-  };
-
-  // Write to output directory
-  const outDir = resolve(options.outputDir);
-  await mkdir(outDir, { recursive: true });
-  const outPath = join(outDir, outputFilename(options.prNumber));
-  await writeFile(outPath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
-
-  process.stdout.write(JSON.stringify({ ok: true, outputPath: outPath, signalCount: signals.length }) + "\n");
-}
-
-// Only auto-run when executed directly (not imported)
-const scriptPath = fileURLToPath(import.meta.url);
-if (process.argv[1] === scriptPath) {
-  run().catch((error) => {
-    if (error.usage) {
-      process.stderr.write(error.usage + "\n\n");
-    }
-    process.stderr.write(formatCliError(error) + "\n");
-    process.exitCode = 1;
-  });
-}

package/src/debt/deep-persona-signals.mjs

@@ -1,266 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { DebtSignalSchema } from "./debt-signal.mjs";
-import { loadDevLoopConfig } from "../config/config.mjs";
-
-// ============================================================================
-// Flag phrase inventory — derived from personas.deep prompt in defaults.yaml
-//
-// Confidence values use the canonical DebtSignalSchema 0..1 range (0.9 = 90%).
-// This matches the schema default: z.number().min(0).max(1).default(1).
-// ============================================================================
-
-/** @type {Array<{ phrase: RegExp, category: string, severity: string, confidence: number }>} */
-const FLAG_PATTERNS = [
-  {
-    phrase: /(?:crossing|crossed|exceeds?)\s+(?:1000|1,000)\+?\s+lines/i,
-    category: "file_size",
-    severity: "high",
-    confidence: 0.9,
-  },
-  {
-    phrase: /conditionals?\s+bolted\s+onto\s+unrelated\s+paths/i,
-    category: "spaghetti_branching",
-    severity: "high",
-    confidence: 0.9,
-  },
-  {
-    phrase: /\bspaghetti\b/i,
-    category: "spaghetti_branching",
-    severity: "high",
-    confidence: 0.9,
-  },
-  {
-    phrase: /thin\s+wrapper/i,
-    category: "thin_wrapper",
-    severity: "medium",
-    confidence: 0.9,
-  },
-  {
-    phrase: /re-export\s*[- ]?only/i,
-    category: "thin_wrapper",
-    severity: "medium",
-    confidence: 0.9,
-  },
-  {
-    phrase: /identity\s+abstraction/i,
-    category: "thin_wrapper",
-    severity: "medium",
-    confidence: 0.9,
-  },
-  {
-    phrase: /feature\s+logic\s+leaking\s+into/i,
-    category: "leaky_feature_logic",
-    severity: "high",
-    confidence: 0.9,
-  },
-  {
-    phrase: /leaking\s+into\s+shared/i,
-    category: "leaky_feature_logic",
-    severity: "high",
-    confidence: 0.9,
-  },
-  {
-    phrase: /cast[- ]?heavy/i,
-    category: "weak_contract",
-    severity: "medium",
-    confidence: 0.9,
-  },
-  {
-    phrase: /optionality[- ]?heavy/i,
-    category: "weak_contract",
-    severity: "medium",
-    confidence: 0.9,
-  },
-  {
-    phrase: /any[- ]?typed\s+contract/i,
-    category: "weak_contract",
-    severity: "medium",
-    confidence: 0.9,
-  },
-  {
-    phrase: /code\s+judo/i,
-    category: "simplification_opportunity",
-    severity: "medium",
-    confidence: 0.9,
-  },
-  {
-    phrase: /prefer\s+deletion\s+over\s+addition/i,
-    category: "simplification_opportunity",
-    severity: "medium",
-    confidence: 0.9,
-  },
-];
-
-const FILE_PATH_RE = /[\w/\-.]+\.(?:m?js|ts|tsx|jsx|mjs)/i;
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-/**
- * Match a comment body against known deep-persona flag phrases.
- * Returns the match when a specific pattern matches, or null when no
- * patterns match the body.
- *
- * @param {string} body
- * @returns {{ category: string, severity: string, confidence: number, matchedPhrase: string|null }|null}
- */
-function matchDeepPersonaFlags(body) {
-  for (const pattern of FLAG_PATTERNS) {
-    if (pattern.phrase.test(body)) {
-      return {
-        category: pattern.category,
-        severity: pattern.severity,
-        confidence: pattern.confidence,
-        matchedPhrase: pattern.phrase.source,
-      };
-    }
-  }
-
-  return null;
-}
-
-/**
- * Extract a file path from a comment body, or return an empty string if none found.
- *
- * @param {string} body
- * @returns {string}
- */
-function extractFilePath(body) {
-  const match = body.match(FILE_PATH_RE);
-  return match ? match[0] : "";
-}
-
-/**
- * Build a debt_signal object from a matched deep-persona comment.
- *
- * @param {object} comment - Normalized comment from parseReviewThreads output
- * @param {string} category - Inferred category
- * @param {string} severity - Severity hint
- * @param {number} confidence - Confidence score (0..1)
- * @param {string|null} matchedPhrase - The regex source that matched
- * @param {{ prNumber: string|number, prUrl: string }} prMeta
- * @returns {object}
- */
-function buildDebtSignal(comment, category, severity, confidence, matchedPhrase, prMeta) {
-  const filePath = extractFilePath(comment.body);
-
-  return {
-    id: randomUUID(),
-    sourceType: "pr_review_deep_persona",
-    signalKind: category,
-    location: filePath ? { filePath } : {},
-    severityHint: severity,
-    timestamp: new Date().toISOString(),
-    confidence,
-    rawPayload: {
-      description: comment.body,
-      metadata: {
-        prNumber: String(prMeta.prNumber),
-        prUrl: prMeta.prUrl,
-        commentId: comment.id,
-        threadId: comment.threadId,
-        isResolved: comment.isResolved ?? false,
-        category,
-        matchedPhrase,
-      },
-    },
-  };
-}
-
-// ============================================================================
-// Public API
-// ============================================================================
-
-/**
- * Extract deep-persona debt_signal artifacts from normalized review-thread JSON.
- *
- * Accepts the output of `parseReviewThreads()` (the `comments` array with
- * normalized `{ id, threadId, author, body, isActionable }` entries).
- *
- * Filters to only bot-authored comments that match known deep-persona flag
- * phrases. Bots are identified by `author.isBot === true` or `author.type === "Bot"`.
- *
- * @param {{ comments: Array<{ id: string, threadId: string, author: { login: string, type: string, isBot: boolean }, body: string, isActionable?: boolean, isResolved?: boolean }>, threads?: Array<{ id: string, isResolved: boolean }> }} parsedOutput - parseReviewThreads() output
- * @param {{ prNumber: string|number, prUrl: string }} prMeta
- * @returns {Array<object>} Array of debt_signal objects compatible with DebtSignalSchema
- */
-export function extractDeepPersonaSignals(parsedOutput, prMeta) {
-  if (!parsedOutput || !Array.isArray(parsedOutput.comments)) {
-    throw new Error("Invalid parsed output: expected { comments: [...] } from parseReviewThreads()");
-  }
-
-  // Build a thread-id → isResolved map for fast lookup
-  const threadResolved = new Map();
-  if (Array.isArray(parsedOutput.threads)) {
-    for (const thread of parsedOutput.threads) {
-      threadResolved.set(thread.id, Boolean(thread.isResolved));
-    }
-  }
-
-  const signals = [];
-
-  for (const comment of parsedOutput.comments) {
-    // Only process bot-authored comments (all Copilot personas emit as bots)
-    if (!comment.author || (!comment.author.isBot && comment.author.type !== "Bot")) {
-      continue;
-    }
-
-    if (!comment.body || comment.body.trim().length === 0) {
-      continue;
-    }
-
-    const match = matchDeepPersonaFlags(comment.body);
-    if (!match) {
-      continue;
-    }
-
-    // Enrich comment with isResolved from thread data
-    const isResolved = threadResolved.has(comment.threadId)
-      ? threadResolved.get(comment.threadId)
-      : (comment.isResolved ?? false);
-
-    const signal = buildDebtSignal(
-      { ...comment, isResolved },
-      match.category,
-      match.severity,
-      match.confidence,
-      match.matchedPhrase,
-      prMeta,
-    );
-
-    // Validate against canonical schema — throw on regression
-    signals.push(DebtSignalSchema.parse(signal));
-  }
-
-  return signals;
-}
-
-/**
- * Return the known deep-persona flag phrase regex sources for inspection.
- *
- * @returns {Array<string>}
- */
-export function getDeepPersonaFlagPhrases() {
-  return FLAG_PATTERNS.map((p) => p.phrase.source);
-}
-
-/**
- * Verify that all known deep-persona flag phrase regex patterns match
- * the loaded deep persona prompt text. Returns an array of regex sources
- * whose patterns did not find any match in the prompt (empty = all match).
- *
- * @returns {Promise<Array<string>>}
- */
-export async function verifyPromptStability() {
-  const { config, errors } = await loadDevLoopConfig();
-  if (errors.length > 0) {
-    throw new Error("Cannot verify prompt stability: config load errors: " +
-      errors.map(e => e.message).join("; "));
-  }
-  const deepPrompt = config?.personas?.deep?.prompt ?? "";
-
-  return FLAG_PATTERNS
-    .filter((p) => !p.phrase.test(deepPrompt))
-    .map((p) => p.phrase.source);
-}

package/src/harness/claude-extension-adapter.mjs

@@ -1,102 +0,0 @@
-import { execFile } from "node:child_process";
-
-import { createExtensionHarnessAdapter } from "./extension-adapter.mjs";
-
-/**
- * Create the Claude Code extension-surface adapter.
- *
- * Implements the same `ExtensionHarnessAdapter` interface as the Pi adapter so
- * `executeDevLoopsCommand` and the extension wiring run unchanged under Claude.
- *
- * - `exec` shells out via `bash -lc` (Claude has no native exec API in core).
- * - lifecycle `on(...)` registrations are stored in `listeners` for hook-driven
- *   dispatch (wired in CA4 / #773); they are not auto-fired here.
- * - `registerCommand(...)` registrations are stored in `commands`.
- * - Claude core has no interactive widget/status surface, so the default
- *   `HarnessContext` reports `hasUI: false` and routes `ui` calls to a sink.
- *
- * @param {Object} [options]
- * @param {string} [options.cwd] - Default cwd for exec and contexts (default: process.cwd()).
- * @param {NodeJS.ProcessEnv} [options.env] - Env for exec (default: process.env).
- * @param {(message: string, level: string) => void} [options.onNotify] - Optional sink for
- *   `ui.notify` (e.g. console). Defaults to a no-op.
- * @returns {import("./extension-adapter.mjs").ExtensionHarnessAdapter & {
- *   listeners: Map<string, Function>,
- *   commands: Map<string, import("./extension-adapter.mjs").HarnessCommandConfig>,
- *   makeContext: (overrides?: {cwd?: string}) => import("./extension-adapter.mjs").HarnessContext,
- * }}
- */
-export function createClaudeExtensionAdapter({
-  cwd = process.cwd(),
-  env = process.env,
-  onNotify = () => {},
-} = {}) {
-  const listeners = new Map();
-  const commands = new Map();
-
-  function exec(command, options = {}) {
-    return new Promise((resolve) => {
-      execFile(
-        "bash",
-        ["-lc", command],
-        {
-          cwd: options.cwd ?? cwd,
-          env,
-          timeout: options.timeout ?? 0,
-          encoding: "utf8",
-          maxBuffer: 64 * 1024 * 1024,
-        },
-        (error, stdout, stderr) => {
-          if (error) {
-            // Match the documented HarnessExecResult contract: `code` is undefined when
-            // the process was killed (e.g. timeout). Consumers branch on `killed` first.
-            const killed = Boolean(error.killed);
-            resolve({
-              code: killed ? undefined : (typeof error.code === "number" ? error.code : 1),
-              stdout: stdout ?? "",
-              stderr: stderr ?? "",
-              killed,
-            });
-            return;
-          }
-          resolve({ code: 0, stdout: stdout ?? "", stderr: stderr ?? "", killed: false });
-        },
-      );
-    });
-  }
-
-  function makeContext({ cwd: ctxCwd } = {}) {
-    return {
-      cwd: ctxCwd ?? cwd,
-      hasUI: false,
-      ui: {
-        notify(message, level = "info") {
-          onNotify(message, level);
-        },
-        setWidget() {},
-        setStatus() {},
-      },
-    };
-  }
-
-  const adapter = createExtensionHarnessAdapter({
-    exec,
-    on(event, handler) {
-      listeners.set(event, handler);
-    },
-    registerCommand(name, config) {
-      commands.set(name, config);
-    },
-  });
-
-  // Freeze the composite so the validated interface guarantee from the factory carries
-  // through to the returned object (which also exposes the #773 dispatch registries).
-  return Object.freeze({
-    exec: adapter.exec,
-    on: adapter.on,
-    registerCommand: adapter.registerCommand,
-    listeners,
-    commands,
-    makeContext,
-  });
-}