@yemi33/minions 0.1.2177 → 0.1.2179

package/engine/lifecycle.js

@@ -915,9 +915,30 @@ function syncPrsFromOutput(output, agentId, meta, config, opts = {}) {
     (projects.length === 1 ? projects[0] : null);
   const useCentral = !defaultProject;
 
-  // Match each PR to its correct project by finding which repo URL appears near the PR number in output
+  // Match each PR to its correct project. W-mqba5ulq000nd255 — primary
+  // strategy is canonical scope: parse the evidence URL into a host scope
+  // (e.g. `github:opg-microsoft/minions`) and find the configured project
+  // whose `getProjectPrScope` matches. This routes the record into the
+  // correctly-scoped project file even when the dispatching agent ran
+  // against a different project (the cross-project PR case that previously
+  // produced stale `_invalidProjectScope` stubs in the wrong file). Falls
+  // back to the legacy substring match (handles legacy non-canonical
+  // configs), then to a repoName-by-_git fallback, then to the dispatching
+  // project (which will get the `_invalidProjectScope` stamp via
+  // normalizePrRecord — preserving today's tracking behavior for orphan /
+  // unknown-owner URLs).
   function resolveProjectForPr(prId) {
     const evidenceUrl = prEvidence.get(prId) || '';
+    // Scope match wins. Use the most-specific URL available: prefer the
+    // direct evidence URL captured alongside the PR id; fall back to the
+    // generic stdout scan if that's empty.
+    const urlScope = shared.getPrScopeInfo(null, evidenceUrl)?.scope || '';
+    if (urlScope) {
+      for (const p of projects) {
+        const projScope = shared.getProjectPrScope(p);
+        if (projScope && projScope === urlScope) return p;
+      }
+    }
     const evidenceText = `${outputText}\n${evidenceUrl}`;
     for (const p of projects) {
       if (!p.prUrlBase) continue;
@@ -1472,7 +1493,14 @@ async function findOpenPrForBranch(meta, config) {
   if (!meta?.branch) return null;
   const projectObj = resolvePrFallbackProject(meta, config);
   if (!projectObj) return null;
-  const host = projectObj.repoHost || 'ado';
+  // BUG-H14 (P-h14-repohost): no silent 'ado' default — if the resolved
+  // project doesn't declare repoHost, bail rather than mis-routing a GitHub
+  // project's branch lookup through the ADO PR-search path.
+  const host = projectObj.repoHost || null;
+  if (!host) {
+    log('debug', `Skipping branch PR lookup: project ${projectObj.name} has no repoHost configured`);
+    return null;
+  }
   if (host === 'github') {
     const ghSlug = projectObj.prUrlBase?.match(/github\.com\/([^/]+\/[^/]+)\/pull/)?.[1];
     if (!ghSlug) return null;
@@ -1981,13 +2009,26 @@ async function updatePrAfterReview(agentId, pr, project, config, resultSummary,
   // The poller will pick up the real status on the next cycle (~3 min).
   let postReviewStatus = null; // null = don't change
   let liveStatus = null;
+  // BUG-H14 (P-h14-repohost): resolve repoHost from the PR's canonical id
+  // FIRST. The previous code derived hostForChecks from the fallback project
+  // (`reviewProject || getProjects(config)[0]`) and silently defaulted to
+  // 'ado' on miss — so a github:* PR found in the central pull-requests.json
+  // (reviewProject=null) with an ADO project as projects[0] was mis-routed to
+  // ado.checkLiveReviewStatus. The fallback project is still consulted when
+  // the id is unparseable, but there is no silent 'ado' default — an
+  // unresolved host is observable (no live check fires).
   const projectObjForChecks = reviewProject || shared.getProjects(config)[0];
-  const hostForChecks = projectObjForChecks?.repoHost || 'ado';
-  const checkFn = hostForChecks === 'github'
-    ? require('./github').checkLiveReviewStatus
-    : require('./ado').checkLiveReviewStatus;
+  const parsedCanonicalReviewId = shared.parseCanonicalPrId(reviewPr.id);
+  const hostFromCanonical = parsedCanonicalReviewId
+    ? parsedCanonicalReviewId.scope.split(':')[0]
+    : null;
+  const hostForChecks = hostFromCanonical || projectObjForChecks?.repoHost || null;
+  let checkFn = null;
+  if (hostForChecks === 'github') checkFn = require('./github').checkLiveReviewStatus;
+  else if (hostForChecks === 'ado') checkFn = require('./ado').checkLiveReviewStatus;
+  else log('warn', `Cannot resolve repoHost for review of ${reviewPr.id} (unparseable canonical id and no project config); skipping live review check.`);
   try {
-    if (projectObjForChecks) {
+    if (projectObjForChecks && checkFn) {
       liveStatus = await checkFn(reviewPr, projectObjForChecks);
     }
   } catch (e) { log('warn', `Post-review status check for ${reviewPr.id}: ${e.message}`); }
@@ -2025,7 +2066,9 @@ async function updatePrAfterReview(agentId, pr, project, config, resultSummary,
     try {
       const reconcileFn = hostForChecks === 'github'
         ? require('./github').dismissPriorViewerChangesRequestedReviews
-        : require('./ado').resetReviewerNegativeVote;
+        : hostForChecks === 'ado'
+          ? require('./ado').resetReviewerNegativeVote
+          : null;
       if (typeof reconcileFn === 'function') {
         const result = await reconcileFn(reviewPr, projectObjForChecks);
         const cleared = !!(result && (result.changed || result.dismissed > 0));
@@ -3395,85 +3438,6 @@ function parseAgentOutput(stdout, runtimeName) {
   return { resultSummary: text, taskUsage: usage, sessionId, model };
 }
 
-/**
- * Parse structured completion block from agent output.
- * Agents produce a ```completion fenced block with key: value pairs.
- * Returns parsed object or null if not found / malformed.
- * If multiple blocks exist, the last one wins (agent may retry).
- *
- * DEPRECATED — slated for removal once telemetry shows zero hits over a 14-day
- * window. Telemetry: see _engine.completionFallbacks in metrics.json (the JSON
- * sidecar at MINIONS_COMPLETION_REPORT is the documented contract; this fenced
- * fallback exists only to support runtimes/agents that have not yet adopted it).
- * Removal is tracked by the P-c8f5e1b3 follow-up plan.
- */
-function parseStructuredCompletion(stdout, runtimeName) {
-  if (!stdout || typeof stdout !== 'string') return null;
-
-  // Extract text from stream-json output if needed
-  const text = extractCompletionText(stdout, runtimeName);
-
-  // Find all ```completion blocks, take the last one
-  const blockPattern = /```completion\s*\n([\s\S]*?)```/g;
-  let lastMatch = null;
-  let m;
-  while ((m = blockPattern.exec(text)) !== null) {
-    lastMatch = m[1];
-  }
-  if (!lastMatch) {
-    const taskCompleteSummary = extractTaskCompleteSummary(stdout);
-    return taskCompleteSummary ? parseCompletionKeyValues(taskCompleteSummary) : null;
-  }
-
-  return parseCompletionKeyValues(lastMatch);
-}
-
-function extractCompletionText(stdout, runtimeName) {
-  let text = stdout;
-  if (typeof stdout === 'string' && stdout.includes('"type":')) {
-    try {
-      const parsed = shared.parseStreamJsonOutput(stdout, runtimeName);
-      if (parsed.text) text = parsed.text;
-    } catch {}
-  }
-  return text;
-}
-
-function hasCompletionFence(stdout, runtimeName) {
-  const text = extractCompletionText(stdout, runtimeName);
-  return /```completion\s*\n[\s\S]*?```/.test(text);
-}
-
-function extractTaskCompleteSummary(stdout) {
-  if (!stdout || typeof stdout !== 'string') return '';
-  let summary = '';
-  for (const rawLine of stdout.split('\n')) {
-    const line = rawLine.trim();
-    if (!line || !line.startsWith('{')) continue;
-    let obj;
-    try { obj = JSON.parse(line); } catch { continue; }
-    if (!obj || typeof obj !== 'object') continue;
-    if (obj.type === 'session.task_complete') {
-      const value = obj.data?.summary;
-      if (typeof value === 'string' && value.trim()) summary = value;
-      continue;
-    }
-    if (obj.type === 'tool.execution_start' && obj.data?.toolName === 'task_complete') {
-      const value = obj.data?.arguments?.summary;
-      if (typeof value === 'string' && value.trim()) summary = value;
-      continue;
-    }
-    if (obj.type === 'assistant.message' && Array.isArray(obj.data?.toolRequests)) {
-      for (const tr of obj.data.toolRequests) {
-        if (tr?.name !== 'task_complete') continue;
-        const value = tr.arguments?.summary || tr.intentionSummary;
-        if (typeof value === 'string' && value.trim()) summary = value;
-      }
-    }
-  }
-  return summary;
-}
-
 function hasActionableFailureClass(value) {
   const normalized = String(value || '').trim().toLowerCase();
   if (!normalized) return false;
@@ -3577,57 +3541,6 @@ function handleInjectionFlag(dispatchItem, agentId, structuredCompletion, config
   return { description, sources, at };
 }
 
-function parseCompletionKeyValues(text) {
-  if (!text || typeof text !== 'string') return null;
-  const result = {};
-  const allowedFields = new Set(shared.COMPLETION_FIELDS || []);
-  const lines = text.trim().split('\n');
-  for (const line of lines) {
-    const normalizedLine = line.trim().replace(/^[-*]\s+/, '');
-    const colonIdx = normalizedLine.indexOf(':');
-    if (colonIdx < 1) continue;
-    const key = normalizedLine.slice(0, colonIdx).trim().toLowerCase();
-    if (allowedFields.size > 0 && !allowedFields.has(key)) continue;
-    const value = normalizedLine.slice(colonIdx + 1).trim();
-    if (key && value) result[key] = value;
-  }
-
-  // Must have at least status, or an actionable failure_class that implies failure.
-  if (!result.status && hasActionableFailureClass(result.failure_class)) result.status = 'failed';
-  if (!result.status) return null;
-  return result;
-}
-
-/**
- * DEPRECATED — slated for removal once telemetry shows zero hits over a 14-day
- * window. Telemetry: see _engine.completionFallbacks in metrics.json (the JSON
- * sidecar at MINIONS_COMPLETION_REPORT is the documented contract; this prose
- * fallback only fires when both the sidecar AND the fenced ```completion block
- * are missing). Removal is tracked by the P-c8f5e1b3 follow-up plan.
- */
-function parseCompletionFieldSummary(text) {
-  if (!text || typeof text !== 'string') return null;
-
-  const allowedFields = new Set(shared.COMPLETION_FIELDS || []);
-  const result = {};
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.trim().replace(/^[-*]\s+/, '');
-    const colonIdx = line.indexOf(':');
-    if (colonIdx < 1) continue;
-    const key = line.slice(0, colonIdx).trim().toLowerCase().replace(/[\s-]+/g, '_');
-    if (!allowedFields.has(key)) continue;
-    const value = line.slice(colonIdx + 1).trim().replace(/^["'`]+|["'`]+$/g, '');
-    if (value) result[key] = value;
-  }
-
-  if (!result.status) return null;
-  const fieldCount = Object.keys(result).length;
-  const status = normalizeCompletionStatus(result.status);
-  const explicitlyFailed = status.startsWith('fail') || status === 'error';
-  if (fieldCount < 2 && !explicitlyFailed) return null;
-  return result;
-}
-
 function parseCompletionReportFile(dispatchItem, opts = {}) {
   const reportPath = dispatchItem?.meta?.completionReportPath || shared.dispatchCompletionReportPath(dispatchItem?.id);
   if (!reportPath || !fs.existsSync(reportPath)) {
@@ -3820,29 +3733,6 @@ function promoteCompletionArtifacts(meta, agentId, dispatchId, structuredComplet
   return { artifacts, notes, agentId, dispatchId };
 }
 
-function persistCompletionReport(dispatchItem, completion, source = 'fallback') {
-  if (!dispatchItem?.id || !completion || typeof completion !== 'object') return completion;
-  const reportPath = dispatchItem?.meta?.completionReportPath || shared.dispatchCompletionReportPath(dispatchItem.id);
-  if (!reportPath) return completion;
-  const report = {
-    ...completion,
-    status: completion.status || completion.outcome || 'unknown',
-    _source: source,
-    _path: reportPath,
-    dispatchId: dispatchItem.id,
-    agent: dispatchItem.agent || null,
-    type: dispatchItem.type || null,
-    completedAt: ts(),
-  };
-  try {
-    safeWrite(reportPath, report);
-    log('info', `Persisted ${source} completion report for ${dispatchItem.id}: ${reportPath}`);
-  } catch (err) {
-    log('warn', `Persist fallback completion report for ${dispatchItem.id}: ${err.message}`);
-  }
-  return report;
-}
-
 function normalizeCompletionStatus(status) {
   return String(status || '').trim().toLowerCase().replace(/[\s_]+/g, '-');
 }
@@ -4487,6 +4377,12 @@ function handleHarnessIterationResult(stdout, structuredCompletion, meta, config
  *   - Returns silently when the PR is no longer active, or when its current
  *     reviewStatus is not in {changes-requested, waiting}. An already-approved
  *     PR doesn't need a re-review.
+ *   - P-e8b1c4d2: Returns silently when engine.autoReReviewPrs === false. This
+ *     mirrors the discovery-driven gate in engine.js:discoverFromPrs so the
+ *     toggle is a single source of truth across BOTH re-review paths
+ *     (open-loop / closure-loop). Without this gate the dashboard switch only
+ *     muted the discovery path, leaving the closure-loop free to keep
+ *     dispatching re-reviews — defeating the operator's intent.
  *   - Idempotent: getPrDispatchDedupeKey + addToDispatch dedup already skips a
  *     second review dispatch for the same (PR, type). No second WI ever lands.
  *   - Soft agent preference: agents whose charter advertises code-review or
@@ -4504,6 +4400,14 @@ function dispatchReReviewForFix(fixDispatchItem, meta, config) {
   if (!addressesReviewWi) return null;
   const pr = meta?.pr;
   if (!pr?.id) return null;
+  // P-e8b1c4d2 — honor the autoReReviewPrs kill-switch in the closure-loop too.
+  // The open-loop discovery path in engine.js gates on the same flag; without
+  // this guard the closure-loop silently bypassed the operator's toggle.
+  const autoReReviewPrs = config?.engine?.autoReReviewPrs ?? shared.ENGINE_DEFAULTS.autoReReviewPrs;
+  if (autoReReviewPrs === false) {
+    log('info', `Re-review skipped for ${pr.id}: engine.autoReReviewPrs is off (closure-loop kill-switch)`);
+    return null;
+  }
   // Re-read live PR state so we don't queue a re-review against an already
   // merged/abandoned PR. The post-completion fix-update may have just flipped
   // reviewStatus to 'waiting'; consult that fresh state via the central read.
@@ -4672,33 +4576,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
     reportCompletion = null;
   }
 
-  const fencedCompletion = (nonceMismatch || reportCompletion) ? null : parseStructuredCompletion(stdout, runtimeName);
-  const summaryCompletion = (nonceMismatch || reportCompletion || fencedCompletion) ? null : parseCompletionFieldSummary(resultSummary);
-  const fallbackCompletion = fencedCompletion || summaryCompletion;
-  const fallbackSource = fencedCompletion && hasCompletionFence(stdout, runtimeName) ? 'fenced-completion' : 'summary-completion';
-  // P-c8f5e1b3 — telemetry: completion-fallback. Emit a grep-able log + bump a
-  // counter in metrics.json whenever the fenced or summary fallback fires (i.e.
-  // the documented sidecar contract was missing). Used to confirm zero adoption
-  // gaps before removing parseStructuredCompletion / parseCompletionFieldSummary
-  // in a follow-up. Sidecar (happy) path is silent — no log, no increment.
-  if (!reportCompletion && fallbackCompletion) {
-    const counterKey = fallbackSource === 'fenced-completion' ? 'fenced' : 'summary';
-    const wiId = dispatchItem.meta?.item?.id || null;
-    log('info', `telemetry: completion-fallback agent=${agentId || 'unknown'} wi=${wiId || 'N/A'} runtime=${runtimeName} source=${fallbackSource}`);
-    try {
-      const metricsPath = path.join(ENGINE_DIR, 'metrics.json');
-      mutateJsonFileLocked(metricsPath, (metrics) => {
-        metrics = metrics || {};
-        if (!metrics._engine) metrics._engine = {};
-        if (!metrics._engine.completionFallbacks) metrics._engine.completionFallbacks = { fenced: 0, summary: 0 };
-        metrics._engine.completionFallbacks[counterKey] = (metrics._engine.completionFallbacks[counterKey] || 0) + 1;
-        return metrics;
-      });
-    } catch (err) {
-      log('warn', `telemetry: completion-fallback metrics write failed: ${err.message}`);
-    }
-  }
-  const structuredCompletion = reportCompletion || persistCompletionReport(dispatchItem, fallbackCompletion, fallbackSource);
+  const structuredCompletion = reportCompletion;
   if (structuredCompletion) {
     if (structuredCompletion.summary) resultSummary = String(structuredCompletion.summary);
     log('info', `Structured completion from ${agentId}: status=${structuredCompletion.status}, pr=${structuredCompletion.pr || 'N/A'}${structuredCompletion._source ? ` (${structuredCompletion._source})` : ''}`);
@@ -5617,6 +5495,94 @@ function diagnoseEmptyOutput(failureClass, code, elapsedMs) {
   return `[empty-output: process exited in ${elapsedMs}ms \u2014 possible causes: machine sleep, network unavailability, auth failure]`;
 }
 
+// W-mqba5ulq000nd255 — Reconciliation sweep: delete PR records flagged with
+// `_invalidProjectScope: { reason: "pr_scope_mismatch" }` IFF a sibling
+// record for the same canonical pr.id exists in another project whose scope
+// matches the PR URL (i.e. the correctly-scoped project owns the canonical
+// record). Sibling-less mismatches are preserved as tracking. Runs once per
+// tick from engine.js after the ADO/GitHub reconcile polls finish.
+//
+// Returns { pruned, scanned } so the engine tick can log a summary line.
+function pruneScopeMismatchDuplicatePrs(config) {
+  config = config || getConfig();
+  const projects = shared.getProjects(config) || [];
+  if (projects.length === 0) return { pruned: 0, scanned: 0 };
+
+  // Map project name -> canonical scope so we can find which project IS the
+  // correctly-scoped owner for a given mismatch record.
+  const scopeByProject = new Map();
+  const projectByScope = new Map();
+  for (const p of projects) {
+    if (!p || !p.name) continue;
+    const sc = shared.getProjectPrScope(p);
+    if (!sc) continue;
+    scopeByProject.set(p.name, sc);
+    projectByScope.set(sc, p);
+  }
+
+  // Index all PRs by canonical id across all projects (post-_scope decoration).
+  const store = require('./pull-requests-store');
+  const allPrs = store.readAllPullRequests() || [];
+  const byId = new Map();
+  for (const pr of allPrs) {
+    if (!pr || !pr.id) continue;
+    if (!byId.has(pr.id)) byId.set(pr.id, []);
+    byId.get(pr.id).push(pr);
+  }
+
+  // Build per-project delete sets keyed by id, so we batch one mutation per
+  // affected project file.
+  const deletesByProject = new Map(); // projectName -> Set(prId)
+  let scanned = 0;
+  let pruned = 0;
+
+  for (const records of byId.values()) {
+    if (records.length < 2) continue;
+    for (const rec of records) {
+      scanned++;
+      if (!rec._invalidProjectScope || rec._invalidProjectScope.reason !== 'pr_scope_mismatch') continue;
+      const correctScope = rec._invalidProjectScope.prScope;
+      if (!correctScope) continue;
+      const correctProject = projectByScope.get(correctScope);
+      if (!correctProject) continue; // no configured project owns the URL — keep as tracking
+      // Sibling check: is there a record under the correct scope for the same id?
+      const sibling = records.find(r => r !== rec && r._scope === correctProject.name);
+      if (!sibling) continue;
+      // Safe to prune.
+      const owningScope = rec._scope;
+      if (!owningScope || owningScope === 'central') continue;
+      if (!deletesByProject.has(owningScope)) deletesByProject.set(owningScope, new Set());
+      deletesByProject.get(owningScope).add(rec.id);
+    }
+  }
+
+  if (deletesByProject.size === 0) return { pruned: 0, scanned };
+
+  for (const [projectName, idsToDelete] of deletesByProject) {
+    const project = projects.find(p => p.name === projectName);
+    if (!project) continue;
+    const prPath = projectPrPath(project);
+    try {
+      shared.mutatePullRequests(prPath, (prs) => {
+        const before = prs.length;
+        const next = prs.filter(p => !idsToDelete.has(p?.id));
+        const deleted = before - next.length;
+        if (deleted > 0) {
+          pruned += deleted;
+          for (const id of idsToDelete) {
+            log('info', `[pull-requests] pruned scope-mismatch duplicate ${id} from project=${projectName} (sibling exists in correctly-scoped project)`);
+          }
+        }
+        return next;
+      });
+    } catch (err) {
+      log('warn', `pruneScopeMismatchDuplicatePrs: failed to mutate ${projectName}: ${err?.message || err}`);
+    }
+  }
+
+  return { pruned, scanned };
+}
+
 module.exports = {
   checkPlanCompletion,
   archivePlan,
@@ -5625,6 +5591,7 @@ module.exports = {
   syncPrdItemStatus,
   reconcilePrdStatuses,
   syncPrsFromOutput,
+  pruneScopeMismatchDuplicatePrs,
   updatePrAfterReview,
   updatePrAfterFix,
   updatePrAfterFixError,
@@ -5638,8 +5605,6 @@ module.exports = {
   parseAgentOutput,
   parseReviewVerdict,
   isReviewBailout,
-  parseStructuredCompletion,
-  parseCompletionFieldSummary,
   parseCompletionNoop,
   detectNonTerminalResultSummary,
   deferNonTerminalCompletion,
@@ -5651,7 +5616,6 @@ module.exports = {
   completionArtifactToNoteEntry,
   mergeArtifactNotes,
   promoteCompletionArtifacts,
-  persistCompletionReport,
   runPostCompletionHooks,
   syncPrdFromPrs,
   resolveWorkItemPath,

package/engine/meeting.js

@@ -916,6 +916,36 @@ function checkMeetingTimeouts(config) {
     const elapsed = Date.now() - roundStartedMs;
     if (elapsed < timeout) continue;
 
+    // BUG-H11: when a hard timeout will fire, kill in-flight meeting
+    // dispatches BEFORE entering the meeting lock so they stop consuming
+    // worker slots / LLM tokens immediately rather than draining over the
+    // next tens of minutes. _killMeetingDispatches takes the dispatch.json
+    // lock and shells out to kill processes — per CLAUDE.md and the
+    // advanceMeetingRound/endMeeting/deleteMeeting pattern at L834, that
+    // MUST run outside the meeting lock. We pre-evaluate eligibility from
+    // the snapshot using the same predicate the mutate callback below
+    // re-checks under lock; if the timeout has already advanced/cleared,
+    // the kill is a no-op on dispatch.json (no matching meetingId entries).
+    const snapshotRoundName = snapshot.status === 'investigating'
+      ? 'investigate'
+      : snapshot.status === 'debating'
+        ? 'debate'
+        : snapshot.status === 'concluding'
+          ? 'conclude'
+          : null;
+    const snapshotHardTimeoutWillFire = elapsed >= hardTimeout && (
+      // Round-timeout branch: non-conclude round + not all participants done
+      (
+        (snapshotRoundName === 'investigate' || snapshotRoundName === 'debate')
+        && !allParticipantsFinishedRound(snapshot, snapshotRoundName, snapshot.round)
+      )
+      // Conclusion-timeout branch: concluding status
+      || snapshot.status === 'concluding'
+    );
+    if (snapshotHardTimeoutWillFire) {
+      _killMeetingDispatches(snapshot.id);
+    }
+
     // Re-evaluate the timeout transition under the file lock to avoid lost
     // updates if an agent finalised mid-tick. Helpers (advanceMeetingIfRoundComplete
     // etc.) operate on the locked-and-rehydrated meeting object.

package/engine/playbook.js

@@ -298,6 +298,11 @@ const PLAYBOOK_OPTIONAL_VARS = new Set([
   'existing_prd_json',    // only set when re-running plan-to-prd over an existing PRD
   'branch_strategy_hint', // only set for shared-branch plans
   'review_note',          // only set on fix/review tasks tied to a comment
+  // P-4d6e2af3 — comma-separated list of target projects for cross-repo
+  // plans. Only set in engine.js's WORK_TYPE.PLAN branch when the WI carries
+  // item._targetProjects (≥2 entries from dashboard.js#buildPlanWorkItem).
+  // Single-project plans legitimately resolve to ''.
+  'target_projects',
   // PR-context vars on non-PR tasks (implement/explore/etc.)
   'pr_id', 'pr_number', 'pr_title', 'pr_branch', 'pr_author', 'pr_url',
   'reviewer',
@@ -868,6 +873,16 @@ function renderPlaybook(type, vars) {
     return (val && String(val).trim()) ? block : '';
   });
 
+  // P-c1f87a92 — negative conditional blocks: {{^key}}...{{/key}} — include
+  // block only if key is FALSY / absent / whitespace-only. Mirror the
+  // positive-block trim() check above so single-value semantics line up
+  // (vars.target_projects = '' or undefined renders the {{^}} branch, the
+  // same way it omits the {{#}} branch).
+  content = content.replace(/\{\{\^(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g, (_, key, block) => {
+    const val = allVars[key];
+    return (val && String(val).trim()) ? '' : block;
+  });
+
   // Substitute variables
   for (const [key, val] of Object.entries(allVars)) {
     content = content.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), String(val));