@yemi33/minions 0.1.2227 → 0.1.2229

package/bin/minions.js

@@ -1168,6 +1168,7 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
     minions cleanup                  Clean temp files, worktrees, zombies
     minions pr comment <repo> <n>    Post a marker-prepended PR comment via gh
                                        --agent <id> --kind <k> [--wi <id>] (--body-file <f> | --body <text>)
+                                       [--harness-file <f> | --harness-json <j>] folds in a "Harnesses used" section
     minions nuke --confirm           Factory reset (delete state, reset config to defaults)
     minions uninstall --confirm      Remove everything + uninstall npm package
 

package/dashboard/js/render-work-items.js

@@ -937,7 +937,7 @@ function _wiRenderDetail(item) {
     });
     if (!pills) return;
     var legend = anyUngrounded
-      ? '<div style="font-size:var(--text-xs);color:var(--muted);margin-top:4px">&#x26A0; dashed = self-reported but not grounded against what the engine exposed</div>'
+      ? '<div style="font-size:var(--text-xs);color:var(--muted);margin-top:4px">&#x26A0; dashed = agent-reported, not verified by the engine</div>'
       : '';
     html += field('Repo harnesses used', '<div style="display:flex;flex-wrap:wrap;gap:4px">' + pills + '</div>' + legend);
   })();

package/dashboard.js

@@ -14214,6 +14214,23 @@ if (require.main === module) {
     const { execSync } = require('child_process');
     setInterval(() => {
       try {
+        // Respect `minions stop` / `minions uninstall` / mid-restart windows.
+        // This is the third engine respawner (alongside engine/supervisor.js and
+        // engine/watchdog.js) and must honor stop-intent too, or it would
+        // resurrect the engine every 30s when stop-intent is set but
+        // control.state is still 'running' (crash mid-stop, or stop-intent set
+        // without a control-state flip). Fail-open: if isStopIntentSet is absent
+        // (forks without a stop-intent producer), proceed with recovery —
+        // matching engine/watchdog.js.
+        let stopWanted = false;
+        if (typeof shared.isStopIntentSet === 'function') {
+          try { stopWanted = !!shared.isStopIntentSet(); } catch { stopWanted = false; }
+        }
+        if (stopWanted) {
+          console.log(`[watchdog] stop-intent set — standing down (no restart)`);
+          return;
+        }
+
         const control = getEngineState();
         if (control.state !== 'running' || !control.pid) return;
 
@@ -14222,7 +14239,10 @@ if (require.main === module) {
         try {
           if (process.platform === 'win32') {
             const out = execSync(`tasklist /FI "PID eq ${control.pid}" /NH`, { encoding: 'utf8', timeout: 3000, windowsHide: true });
-            alive = out.includes(String(control.pid));
+            // Word-boundary + image-name match (mirrors engine/restart-health.js)
+            // so a digit-substring collision in another column can't read a dead
+            // engine pid as alive and suppress a needed respawn.
+            alive = shared.tasklistOutputShowsPid(out, control.pid, { imageName: 'node' });
           } else {
             process.kill(control.pid, 0); // signal 0 = check existence
             alive = true;

package/docs/harness-transparency.md

@@ -110,11 +110,15 @@ evaluation pass) can see what tooling drove a dispatch:
    and ⚠️-marked), and returns `''` for an empty/absent record. The GitHub
    comment path folds it in via `engine/gh-comment.js#buildMinionsCommentBody`
    (optional `harnessUsed` arg, threaded through `postPrComment` /
-   `postPrReviewComment` / `postPrReview`); the Azure DevOps path has no
-   engine-side comment poster (agents post via `az repos pr comment` / REST),
-   so review/fix agents append the **byte-identical** section themselves per
-   `playbooks/shared-rules.md` → "Harness transparency / self-report". Both
-   surfaces consume the one renderer, so there is no second formatter to drift.
+   `postPrReviewComment` / `postPrReview`); the Azure DevOps path mirrors it via
+   `engine/ado-comment.js#postAdoPrComment` (same builder, same `harnessUsed`
+   arg). Both posters are reached from the `minions pr comment` CLI, which turns
+   `--harness-file` / `--harness-json` into the grounded record and folds the
+   **byte-identical** section in for the agent. Only the raw `gh pr comment` /
+   `az repos pr comment` / REST fallbacks bypass that chokepoint, so on those
+   paths review/fix agents append the section themselves per
+   `playbooks/shared-rules.md` → "Harness transparency / self-report". Every
+   surface consumes the one renderer, so there is no second formatter to drift.
 2. **notes/inbox digest** — harness usage is summarized into the learnings /
    inbox stream that feeds consolidation, so cross-task patterns ("everyone
    reaches for skill X on Android fixes") become visible to the team-memory

package/docs/worktree-lifecycle.md

@@ -47,6 +47,34 @@ recycle worktree dirs across branches.
   → `git checkout --detach origin/<main>` → mark IDLE.
 - **State** at `engine/worktree-pool.json`; git ops outside any lock.
 
+## Ownership marker is never "dirty" (#284)
+
+The reused-worktree preflight (`assertCleanSharedWorktree`) builds its
+dirty-file list from `git status --porcelain`. The engine's own
+ownership marker `.minions-worktree` (`shared.WORKTREE_OWNER_MARKER`) is
+gitignored in the repo's *current* tree, but a reused worktree that
+checks out a branch whose tree predates that `.gitignore` line (or a
+foreign repo) surfaces the marker as an untracked `?? .minions-worktree`
+entry. Counting that engine-stamped artifact as filesystem-dirt used to
+flip an otherwise-safe-to-reuse worktree (no upstream, HEAD at main tip)
+into the conservative quarantine path → a non-retryable `WORKTREE_DIRTY`
+failure for the whole work item.
+
+`shared.isWorktreeOwnerMarkerStatusLine(porcelainLine)` recognizes a
+porcelain line that refers ONLY to the root-level marker; the preflight
+filters it out of `dirtyFiles` at every status read (initial probe,
+post-reset re-verify) and the dirty-files prompt-injection site
+(`engine.js`). **An untracked marker alone is a CLEAN tree for reuse.**
+A same-named file nested in a subdir is NOT the marker and stays dirty;
+the marker filter never masks a genuine user/agent edit beside it.
+
+When the dirt is real and the worktree can't be auto-healed, the engine
+still quarantines and fails non-retryably, and the quarantine
+auto-recovery loop re-queues the item once in a fresh worktree (see
+**Auto-recovery cap** below). The spawn-error completion report
+distinguishes the **original worktree-preflight issue** from a
+**retry-in-fresh-worktree** failure via `_quarantineRecoveryCount`.
+
 ## Quarantine path (dirty / divergent)
 
 When `discoverFromWorkItems` finds a worktree in a `WORKTREE_DIRTY`,

package/engine/cli.js

@@ -6,7 +6,7 @@
 const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
-const { safeRead, safeJson, safeWrite, mutateControl, mutateWorkItems, ts, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, REVIEW_STATUS, DISPATCH_RESULT } = shared;
+const { safeRead, safeJson, safeJsonArr, safeWrite, mutateControl, mutateWorkItems, ts, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, REVIEW_STATUS, DISPATCH_RESULT } = shared;
 const queries = require('./queries');
 const { getConfig, getControl, getDispatch, getAgentStatus,
   MINIONS_DIR, ENGINE_DIR, AGENTS_DIR, PLANS_DIR, PRD_DIR, CONTROL_PATH, DISPATCH_PATH } = queries;
@@ -250,7 +250,7 @@ const CLI_COMMAND_DOCS = Object.freeze({
   'mcp-sync': { args: '',                      summary: 'Print harness propagation diagnostic (same source as `minions doctor --harness`; read-only, no writes)' },
   doctor:     { args: '[--harness]',           summary: 'Check prerequisites and runtime health (--harness: print harness propagation diagnostic)' },
   config:     { args: 'set-cli <R> [--model M]', summary: 'Persist defaultCli/defaultModel without starting' },
-  pr:         { args: 'comment <repo> <prNumber> --agent <id> --kind <k> [--wi <id>] [--body-file <f>|--body <text>]', summary: 'Post a marker-prepended PR comment via gh' },
+  pr:         { args: 'comment <repo> <prNumber> --agent <id> --kind <k> [--wi <id>] [--harness-file <f>|--harness-json <j>] [--body-file <f>|--body <text>]', summary: 'Post a marker-prepended PR comment via gh' },
   bridge:     { args: 'status|health|enable|disable',         summary: 'Constellation bridge: toggle and inspect the read-only cross-repo feed' },
 });
 
@@ -413,6 +413,68 @@ function _applyRuntimeFlags({ cli, model, modelExplicit }) {
   return { warnings, applied: true };
 }
 
+// resolveHarnessUsedForComment(flags) — P-7a3c9e21. Turn the `minions pr comment`
+// harness flags into a grounded `harnessUsed` record suitable for the posters'
+// `harnessUsed` param (engine/gh-comment.js / engine/ado-comment.js), which fold
+// it via buildMinionsCommentBody -> buildHarnessUsedSection.
+//
+// Source precedence: `--harness-file <path>` (JSON on disk) wins over the inline
+// `--harness-json <json>` convenience; neither supplied -> returns undefined so
+// the comment body is byte-identical to today (no section). Read/parse failures
+// are HARD errors (process.exit(2) with the offending message) — never a silent
+// drop. Grounding uses the spawn-time `_harnessPropagated` manifest located by
+// dispatch id (explicit `--dispatch-id` -> else basename(MINIONS_COMPLETION_REPORT,
+// '.json')); an unresolvable manifest passes null, marking every entry
+// grounded:false — the honest "no record" state, not a fatal condition.
+function resolveHarnessUsedForComment(flags) {
+  const fileArg = flags['harness-file'];
+  const jsonArg = flags['harness-json'];
+
+  let raw;
+  if (fileArg !== undefined) {
+    try {
+      raw = fs.readFileSync(fileArg, 'utf8');
+    } catch (e) {
+      console.error(`error: could not read --harness-file ${fileArg}: ${e.message}`);
+      process.exit(2);
+    }
+  } else if (jsonArg !== undefined) {
+    raw = String(jsonArg);
+  } else {
+    return undefined;
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    const src = fileArg !== undefined ? `--harness-file ${fileArg}` : '--harness-json';
+    console.error(`error: invalid JSON in ${src}: ${e.message}`);
+    process.exit(2);
+  }
+
+  // Resolve the grounding manifest best-effort: explicit id -> completion-report
+  // basename. A missing/unresolvable manifest is non-fatal (groundHarnessUsed
+  // with null propagated marks everything grounded:false).
+  const dispatchId = flags['dispatch-id']
+    || path.basename(process.env.MINIONS_COMPLETION_REPORT || '', '.json')
+    || undefined;
+  let propagated = null;
+  if (dispatchId) {
+    try {
+      const dispatch = getDispatch();
+      for (const queue of ['active', 'completed', 'pending']) {
+        const list = Array.isArray(dispatch?.[queue]) ? dispatch[queue] : null;
+        if (!list) continue;
+        const found = list.find(d => d && d.id === dispatchId);
+        if (found && found._harnessPropagated) { propagated = found._harnessPropagated; break; }
+      }
+    } catch { propagated = null; }
+  }
+
+  return shared.groundHarnessUsed(parsed, propagated);
+}
+
 const commands = {
   start(...startArgs) {
     // Apply --cli / --model fleet flags before any engine wiring touches
@@ -782,7 +844,7 @@ const commands = {
               const projName = item.meta.project?.name;
               if (projName) {
                 const prPath = path.join(MINIONS_DIR, 'projects', projName, 'pull-requests.json');
-                const prs = safeJson(prPath) || [];
+                const prs = safeJsonArr(prPath);
                 const matchingPr = prs.find(pr =>
                   (pr.prdItems || []).includes(item.meta.item.id) &&
                   pr.status !== 'abandoned' && pr.status !== 'closed'
@@ -1760,13 +1822,13 @@ const commands = {
           }
         }
         if (exists && name === 'pullRequests') {
-          const prs = safeJson(filePath) || [];
+          const prs = safeJsonArr(filePath);
           const pending = prs.filter(p => p.status === PR_STATUS.ACTIVE && (p.reviewStatus === REVIEW_STATUS.PENDING || p.reviewStatus === REVIEW_STATUS.WAITING));
           const needsFix = prs.filter(p => p.status === PR_STATUS.ACTIVE && p.reviewStatus === REVIEW_STATUS.CHANGES_REQUESTED);
           console.log(`    PRs: ${pending.length} pending review, ${needsFix.length} need fixes`);
         }
         if (exists && name === 'workItems') {
-          const items = safeJson(filePath) || [];
+          const items = safeJsonArr(filePath);
           const queued = items.filter(i => i.status === WI_STATUS.QUEUED);
           console.log(`    Items: ${queued.length} queued`);
         }
@@ -1982,6 +2044,11 @@ const commands = {
       console.log('  GitHub: minions pr comment <repo> <prNumber> --agent <id> --kind <k> [--wi <id>] (--body-file <path> | --body <text>)');
       console.log('  ADO:    minions pr comment <prNumber> --host ado --ado-org <org> --ado-project <proj> --repo-id <id> --agent <id> --kind <k> [--wi <id>] (--body-file <path> | --body <text>)');
       console.log('');
+      console.log('Optional harness self-report (folded into the collapsible "Harnesses used" section):');
+      console.log('  --harness-file <path>   JSON file with the { skills, mcpServers, commands, docs } record (wins over --harness-json)');
+      console.log('  --harness-json <json>   same record inline as a JSON string');
+      console.log('  --dispatch-id <id>      grounding manifest override (else basename of $MINIONS_COMPLETION_REPORT)');
+      console.log('');
       console.log('Posts a PR comment with the hidden minions marker, the collapsible');
       console.log('"Harnesses used" section, and the brand link folded in by the shared');
       console.log('builder — so engine classifiers identify agent-authored comments by');
@@ -2040,6 +2107,12 @@ const commands = {
       process.exit(2);
     }
 
+    // P-7a3c9e21 — thread the consulted-sources footprint into both posters so
+    // the auto-folded "Harnesses used" <details> section the help already
+    // promises is actually rendered. Resolved once (host-neutral); absent flags
+    // -> undefined -> body byte-identical to today.
+    const harnessUsed = resolveHarnessUsedForComment(flags);
+
     // ── Azure DevOps: <prNumber> --host ado --ado-org --ado-project --repo-id ──
     if (isAdo) {
       const [prNumberRaw] = positional;
@@ -2059,7 +2132,7 @@ const commands = {
       const orgBase = flags['org-base'] || `https://dev.azure.com/${adoOrg}`;
       const adoComment = require('./ado-comment');
       adoComment.postAdoPrComment({
-        orgBase, project, repositoryId, prNumber, body, agentId, kind, workItemId,
+        orgBase, project, repositoryId, prNumber, body, agentId, kind, workItemId, harnessUsed,
       }).then((result) => {
         if (result && result.threadId) console.log(`ADO thread ${result.threadId} created`);
       }).catch((e) => {
@@ -2084,7 +2157,7 @@ const commands = {
 
     try {
       const result = ghComment.postPrComment({
-        repo, prNumber, body, agentId, kind, workItemId,
+        repo, prNumber, body, agentId, kind, workItemId, harnessUsed,
       });
       if (result.output) console.log(result.output);
     } catch (e) {
@@ -2223,6 +2296,8 @@ module.exports = {
   _readDispatchPid: readDispatchPid,
   _normalizeSessionBranch: normalizeSessionBranch,
   _dispatchSessionBranch: dispatchSessionBranch,
+  // P-7a3c9e21 — harness-flag resolver exported for CLI-threading tests.
+  _resolveHarnessUsedForComment: resolveHarnessUsedForComment,
   // W-mpcyvff6000pf828 (#2653) — heartbeat writer + factory exported for tests
   _writeHeartbeatNow: writeHeartbeatNow,
   _createHeartbeatInterval: createHeartbeatInterval,

package/engine/comment-format.js

@@ -112,7 +112,7 @@ function buildHarnessUsedSection(harnessUsed) {
   if (lines.length === 0) return '';
 
   const legend = anyUngrounded
-    ? `\n\n> ${HARNESS_WARN_ICON} self-reported but not grounded against what the engine exposed.`
+    ? `\n\n> ${HARNESS_WARN_ICON} agent-reported, not verified by the engine`
     : '';
 
   return `<details>\n<summary>${HARNESS_SUMMARY_ICON} Harnesses used (${lines.length})</summary>\n\n`

package/engine/gh-token.js

@@ -21,7 +21,7 @@
 const { execFileSync } = require('child_process');
 const path = require('path');
 const shared = require('./shared');
-const { safeJson, MINIONS_DIR, log } = shared;
+const { safeJsonObj, MINIONS_DIR, log } = shared;
 
 const TOKEN_TTL_MS = 30 * 60 * 1000; // 30 minutes
 const FETCH_TIMEOUT_MS = 10000;       // 10s — same ceiling as `gh api user`
@@ -40,7 +40,7 @@ function _readConfig(opts = {}) {
     return _cachedConfig;
   }
   const configPath = path.join(MINIONS_DIR, 'config.json');
-  _cachedConfig = safeJson(configPath) || {};
+  _cachedConfig = safeJsonObj(configPath);
   _cachedConfigAt = Date.now();
   return _cachedConfig;
 }

package/engine/github.js

@@ -633,11 +633,11 @@ async function forEachActiveGhPr(config, callback) {
       if (updated) {
         // Also update title/author/branch if still placeholder
         const currentTitle = pr.title || '';
-        if (!currentTitle || currentTitle.includes('polling...') || pr.agent === 'human' || pr.description === undefined) {
+        if (shared.isPlaceholderPrTitle(currentTitle) || pr.agent === 'human' || pr.description === undefined) {
           const prData = await ghApi(`/pulls/${prNum}`, slug);
           if (prData) {
             const latestTitle = pr.title || '';
-            if (!latestTitle || latestTitle.includes('polling...') || /[{}"\[\]]/.test(latestTitle) || /^[0-9a-f-]{8,}$/i.test(latestTitle)) {
+            if (shared.isPlaceholderPrTitle(latestTitle)) {
               pr.title = (prData.title || latestTitle).slice(0, 120);
             }
             if (pr.description === undefined) pr.description = (prData.body || '').slice(0, 500);
@@ -752,10 +752,7 @@ async function pollPrStatus(config) {
     // stay stuck on "PR #N (polling...)" forever. `prData` is already in
     // hand from line 622 — no extra API call needed.
     const currentTitleForBackfill = pr.title || '';
-    if (!currentTitleForBackfill
-        || currentTitleForBackfill.includes('polling...')
-        || /[{}"\[\]]/.test(currentTitleForBackfill)
-        || /^[0-9a-f-]{8,}$/i.test(currentTitleForBackfill)) {
+    if (shared.isPlaceholderPrTitle(currentTitleForBackfill)) {
       if (prData.title) {
         const nextTitle = String(prData.title).slice(0, 120);
         if (pr.title !== nextTitle) {

package/engine/lifecycle.js

@@ -32,9 +32,6 @@ function checkPlanCompletion(meta, config) {
   // terminal artifacts; missing primary means "gone", not "needs recovery".
   const plan = safeJsonNoRestore(planPath);
   if (!plan?.missing_features) return;
-  if (plan.status === PLAN_STATUS.COMPLETED) {
-    if (plan._completionNotified) return;
-  }
 
   const projects = shared.getProjects(config);
 
@@ -43,6 +40,21 @@ function checkPlanCompletion(meta, config) {
   const planItems = allWorkItems.filter(w => w.sourcePlan === planFile && w.itemType !== 'pr' && w.itemType !== 'verify');
   if (planItems.length === 0) return;
 
+  // W-mqk5ld3p: verify-creation must be a pure function of work-item state,
+  // independent of who/what set `status: completed`. We do NOT short-circuit on
+  // the raw `_completionNotified` boolean — a PRD can land on disk pre-completed
+  // with the flag already set (out-of-band write by the plan-to-prd / pipeline
+  // path), and the legacy top-of-function `if (_completionNotified) return` then
+  // permanently skipped the aggregate build/test verify gate. Instead the flag
+  // gates ONLY the one-shot completion summary (below); control always falls
+  // through to the verify-creation block, which re-checks for an existing verify
+  // WI under the file lock and is therefore safe to reach every scan. The one
+  // exception is the REOPEN sub-path (terminal verify → re-open): that is a
+  // plan-modification concern (the dashboard clears `_completionNotified` when it
+  // re-opens a plan), so it is gated on `!alreadyNotified` to avoid bouncing an
+  // already-done verify on every steady-state scan.
+  const alreadyNotified = plan.status === PLAN_STATUS.COMPLETED && !!plan._completionNotified;
+
   // Hard completion gate: every PRD feature ID must have a corresponding work item in a terminal state.
   const planFeatureIds = new Set((plan.missing_features || []).map(f => f.id).filter(Boolean));
   const workItemById = {};
@@ -146,18 +158,24 @@ function checkPlanCompletion(meta, config) {
     ...uniquePrs.map(pr => `- ${pr.id}: ${pr.title || ''} ${pr.url || ''}`),
   ].filter(Boolean).join('\n');
 
-  // Write summary to notes/inbox
-  const summarySlug = `prd-completion-${planFile.replace('.json', '')}`;
-  shared.writeToInbox('engine', summarySlug, summary);
-  log('info', `PRD completion summary written to notes/inbox/${summarySlug}`);
-
-  // Persist completed status + _completionNotified via file lock
-  mutateJsonFileLocked(planPath, (data) => {
-    data.status = PLAN_STATUS.COMPLETED;
-    data.completedAt = plan.completedAt;
-    data._completionNotified = true;
-    return data;
-  });
+  // Write summary to notes/inbox + flip _completionNotified — one-shot side
+  // effects, skipped for a pre-completed PRD that already carried the flag
+  // (alreadyNotified). The verify-creation block below still runs and is
+  // idempotent, so the plan still gets its verify gate without a duplicate
+  // summary or a redundant flag write.
+  if (!alreadyNotified) {
+    const summarySlug = `prd-completion-${planFile.replace('.json', '')}`;
+    shared.writeToInbox('engine', summarySlug, summary);
+    log('info', `PRD completion summary written to notes/inbox/${summarySlug}`);
+
+    // Persist completed status + _completionNotified via file lock
+    mutateJsonFileLocked(planPath, (data) => {
+      data.status = PLAN_STATUS.COMPLETED;
+      data.completedAt = plan.completedAt;
+      data._completionNotified = true;
+      return data;
+    });
+  }
 
   // Resolve the primary project for writing new work items (PR, verify).
   // Multi-project plans (no plan.project) derive primary from the done items —
@@ -255,6 +273,14 @@ function checkPlanCompletion(meta, config) {
       }
 
       if (isReopenableVerify(existingVerify)) {
+        // Re-opening a terminal verify is a plan-MODIFICATION action, not part of
+        // steady-state completion. The dashboard clears `_completionNotified` when
+        // it re-opens a plan, so only re-open here on a fresh completion; otherwise
+        // an already-done verify would bounce on every periodic scan (W-mqk5ld3p).
+        if (alreadyNotified) {
+          log('info', `Plan ${planFile}: verify WI ${existingVerify.id} for ${projName} already ${existingVerify.status} and plan already notified — leaving as-is`);
+          continue;
+        }
         const verifyProject = existingVerify.project || projName;
         const vProject = shared.resolveProjectSource(verifyProject, projects, { allowCentral: false }).project || p;
         const vWiPath = shared.projectWorkItemsPath(vProject);

package/engine/pipeline.js

@@ -8,7 +8,7 @@ const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
-const { safeJson, safeJsonNoRestore, safeWrite, safeRead, safeReadDir, uid, log, ts, dateStamp, mutateJsonFileLocked, mutateWorkItems, mutatePipelineRuns, slugify, formatTranscriptEntry, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, READ_ONLY_ROOT_TASK_TYPES, ENGINE_DEFAULTS, MINIONS_DIR } = shared;
+const { safeJson, safeJsonObj, safeJsonArr, safeJsonNoRestore, safeWrite, safeRead, safeReadDir, uid, log, ts, dateStamp, mutateJsonFileLocked, mutateWorkItems, mutatePipelineRuns, slugify, formatTranscriptEntry, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, READ_ONLY_ROOT_TASK_TYPES, ENGINE_DEFAULTS, MINIONS_DIR } = shared;
 const routing = require('./routing');
 const http = require('http');
 const { shouldRunNow } = require('./scheduler');
@@ -70,7 +70,7 @@ function deletePipeline(id) {
 // ── Run State ────────────────────────────────────────────────────────────────
 
 function getPipelineRuns() {
-  return safeJson(PIPELINE_RUNS_PATH) || {};
+  return safeJsonObj(PIPELINE_RUNS_PATH);
 }
 
 function getActiveRun(pipelineId) {
@@ -335,7 +335,7 @@ function evaluateCondition(condition, ctx) {
       // True when all work items created by the pipeline are done (not failed)
       if (!run) return false;
       const wiPath = CENTRAL_WI_PATH;
-      const workItems = safeJson(wiPath) || [];
+      const workItems = safeJsonArr(wiPath);
       const allProjectWi = shared.getProjects(config).reduce((acc, p) => {
         return acc.concat(safeJson(shared.projectWorkItemsPath(p)) || []);
       }, []);
@@ -876,7 +876,7 @@ function isStageComplete(stage, stageState, run, config) {
     case STAGE_TYPE.TASK: {
       // Check root + all project work-items.json (WIs may be moved to project paths)
       const wiPath = CENTRAL_WI_PATH;
-      const workItems = safeJson(wiPath) || [];
+      const workItems = safeJsonArr(wiPath);
       const allProjectWi = shared.getProjects(config).reduce((acc, p) => {
         return acc.concat(safeJson(shared.projectWorkItemsPath(p)) || []);
       }, []);
@@ -900,7 +900,7 @@ function isStageComplete(stage, stageState, run, config) {
     case STAGE_TYPE.PLAN: {
       // Plan stage completion: PRD conversion done + all materialized work items done
       const wiPath = CENTRAL_WI_PATH;
-      const workItems = safeJson(wiPath) || [];
+      const workItems = safeJsonArr(wiPath);
       const allProjectWi = shared.getProjects(config).reduce((acc, p) => {
         return acc.concat(safeJson(shared.projectWorkItemsPath(p)) || []);
       }, []);
@@ -1064,7 +1064,7 @@ async function discoverPipelineWork(config) {
           let output = '';
           if (stage.type === STAGE_TYPE.TASK) {
             const wiPath = CENTRAL_WI_PATH;
-            const workItems = safeJson(wiPath) || [];
+            const workItems = safeJsonArr(wiPath);
             const projWi = shared.getProjects(config).reduce((acc, p) => acc.concat(safeJson(shared.projectWorkItemsPath(p)) || []), []);
             const allWi = [...workItems, ...projWi];
             output = (stageState.artifacts?.workItems || []).map(id => {

package/engine/projects.js

@@ -88,7 +88,7 @@ function _centralDispatchDefaultedToProject(d, removedProject, projects) {
 function _collectProjectlessCentralDispatchItemIds(removedProject, projects) {
   const dispatchPath = path.join(MINIONS_DIR, 'engine', 'dispatch.json');
   const ids = new Set();
-  const state = shared.safeJson(dispatchPath) || {};
+  const state = shared.safeJsonObj(dispatchPath);
   for (const queue of ['pending', 'active']) {
     for (const d of Array.isArray(state?.[queue]) ? state[queue] : []) {
       if (_centralDispatchDefaultedToProject(d, removedProject, projects)) ids.add(d.meta.item.id);

package/engine/routing.js

@@ -8,7 +8,7 @@ const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
 
-const { safeJson, safeRead, log, ts, WORK_TYPE } = shared;
+const { safeJson, safeJsonObj, safeRead, log, ts, WORK_TYPE } = shared;
 const { ENGINE_DIR, DISPATCH_PATH } = queries;
 
 const MINIONS_DIR = shared.MINIONS_DIR;
@@ -84,7 +84,7 @@ function getMonthlySpend(agentId) {
 
 function getAgentErrorRate(agentId) {
   const metricsPath = path.join(ENGINE_DIR, 'metrics.json');
-  const metrics = safeJson(metricsPath) || {};
+  const metrics = safeJsonObj(metricsPath);
   const m = metrics[agentId];
   if (!m) return 0;
   const total = m.tasksCompleted + m.tasksErrored;
@@ -93,7 +93,7 @@ function getAgentErrorRate(agentId) {
 
 function isAgentIdle(agentId) {
   // Dispatch queue is the single source of truth for agent availability
-  const dispatch = safeJson(DISPATCH_PATH) || {};
+  const dispatch = safeJsonObj(DISPATCH_PATH);
   return !(dispatch.active || []).some(d => d.agent === agentId);
 }
 

package/engine/shared.js

@@ -6553,6 +6553,32 @@ function findPrRecord(prs, prRef, project = null) {
   return numberMatches.length === 1 ? numberMatches[0] : null;
 }
 
+// Issue #289: single source of truth for "is this stored PR title a
+// placeholder/fallback that should be backfilled from the live platform
+// title on the next poll?". Recognizes:
+//   - empty / missing titles
+//   - the link-time "...(polling...)" placeholder
+//   - serialized-JSON / agent-output leakage (contains {}"[] chars)
+//   - bare hex/uuid-ish ids (>= 8 hex/dash chars)
+//   - the fallback WRITER shapes "PR created by <agent>" (engine/lifecycle.js)
+//     and bare "PR #<n>" (engine/ado.js central poller)
+// The WRITER (engine/lifecycle.js) and the DETECTORS (engine/github.js,
+// engine/ado.js) MUST agree — route every site through this helper so they
+// cannot drift apart again (the github poller previously never backfilled a
+// frozen "PR created by Ripley" title because its detector didn't know the shape).
+function isPlaceholderPrTitle(title) {
+  const t = typeof title === 'string'
+    ? title.trim()
+    : (title == null ? '' : String(title).trim());
+  if (!t) return true;
+  if (t.includes('polling...')) return true;
+  if (/[{}"\[\]]/.test(t)) return true;
+  if (/^[0-9a-f-]{8,}$/i.test(t)) return true;
+  if (/^PR created by /i.test(t)) return true;
+  if (/^PR #\d+$/i.test(t)) return true;
+  return false;
+}
+
 function snapshotPrRecord(pr) {
   if (pr === undefined) return undefined;
   return JSON.parse(JSON.stringify(pr));
@@ -7197,6 +7223,23 @@ function killImmediate(proc) {
   }
 }
 
+// Decide whether a Windows `tasklist /FI "PID eq <pid>" /NH` output proves the
+// pid is alive. A bare `out.includes(String(pid))` can read a DEAD pid as alive
+// on a digit-substring collision — the pid appears inside another column (a
+// larger PID, a memory-KB figure, a session id). Require a word-boundary match
+// (`\b<pid>\b`) and, when an `imageName` is supplied, that the expected process
+// image is present too. Mirrors the hardened check in engine/restart-health.js.
+// Pure (no shell-out) so callers can pass captured output and unit tests can
+// feed crafted samples.
+function tasklistOutputShowsPid(out, pid, { imageName } = {}) {
+  if (!out) return false;
+  const n = Number(pid);
+  if (!Number.isInteger(n) || n <= 0) return false;
+  if (!new RegExp(`\\b${n}\\b`).test(out)) return false;
+  if (imageName && !out.toLowerCase().includes(String(imageName).toLowerCase())) return false;
+  return true;
+}
+
 // W-mq0e2dae000a003d — cross-platform CPU-seconds sampler used by the
 // spawn-phase watchdog to decide whether a process is genuinely wedged
 // vs busy. Returns the cumulative user+system CPU time in seconds, or
@@ -8409,6 +8452,32 @@ function hasWorktreeOwnerMarker(worktreePath) {
   }
 }
 
+// True when a `git status --porcelain` line refers ONLY to the engine's own
+// worktree-ownership marker (.minions-worktree) at the worktree root (#284).
+// The marker is gitignored in the repo's current tree, but a reused worktree
+// that checks out a branch whose tree predates that .gitignore line (or a
+// foreign repo) surfaces the marker as an untracked `?? .minions-worktree`
+// entry. Counting that engine-stamped artifact as "dirty" would fail (and
+// quarantine) an otherwise-safe-to-reuse worktree. Callers filter the marker
+// out of the dirty-file list before deciding a worktree is dirty.
+function isWorktreeOwnerMarkerStatusLine(porcelainLine) {
+  if (!porcelainLine) return false;
+  const line = String(porcelainLine).trim();
+  if (!line) return false;
+  // Porcelain v1: "XY <path>" — for an untracked file XY is "??". Strip the
+  // status code (1-2 chars from the porcelain status alphabet) and the
+  // following whitespace; fall back to the raw line if it doesn't match.
+  const m = line.match(/^[ MTADRCU?!]{1,2}\s+(.*)$/);
+  let p = m ? m[1] : line;
+  // git quotes paths containing special chars; the marker name never needs it
+  // but strip defensively. Then normalize separators and a leading "./".
+  if (p.length >= 2 && p.startsWith('"') && p.endsWith('"')) p = p.slice(1, -1);
+  p = p.replace(/\\/g, '/').replace(/^\.\//, '');
+  // The marker is only ever stamped at the worktree root — a same-named file
+  // nested in a subdir is NOT the ownership marker and stays "dirty".
+  return p === WORKTREE_OWNER_MARKER;
+}
+
 function slugify(text, maxLen = 50) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, maxLen);
 }
@@ -8791,6 +8860,7 @@ module.exports = {
   isAdoPrScopeCompatible,
   getCanonicalPrId,
   findPrRecord,
+  isPlaceholderPrTitle,
   snapshotPrRecord,
   applyPrFieldDelta,
   normalizePrRecord,
@@ -8860,6 +8930,7 @@ module.exports = {
   sleepMs,
   killGracefully,
   killImmediate,
+  tasklistOutputShowsPid,
   getProcessCpuSeconds,
   killByPidImmediate,
   killByPidsImmediate,
@@ -8875,6 +8946,7 @@ module.exports = {
   WORKTREE_OWNER_MARKER,
   writeWorktreeOwnerMarker,
   hasWorktreeOwnerMarker,
+  isWorktreeOwnerMarkerStatusLine,
   _normalizeWorktreePath, // exported for testing
   _writeWorktreeSkipLiveInboxNote, // exported for testing
   _retryFsOp, // exported for testing (W-mq5o6bvy000x7191)

package/engine/supervisor.js

@@ -103,7 +103,14 @@ function isPidAlive(pid) {
       const out = execSync(`tasklist /FI "PID eq ${pid}" /NH`, {
         encoding: 'utf8', timeout: 3000, windowsHide: true,
       });
-      return out.includes(String(pid));
+      // Word-boundary + image-name match (mirrors engine/restart-health.js) so a
+      // digit-substring collision in another column can't read a dead pid as
+      // alive. Fall back to an inline regex if shared.js isn't loadable.
+      const shared = _sharedOrNull();
+      if (shared && typeof shared.tasklistOutputShowsPid === 'function') {
+        return shared.tasklistOutputShowsPid(out, pid, { imageName: 'node' });
+      }
+      return new RegExp(`\\b${pid}\\b`).test(out) && out.toLowerCase().includes('node');
     }
     process.kill(pid, 0);
     return true;
@@ -180,12 +187,30 @@ function _tokenizeCmdline(cmdline) {
 // byte-identical `path.join(MINIONS_DIR, '<script>.js')`, so exact script-token
 // match catches all of them while a foreign process that only *names* the path
 // is left alone (fail-safe: never kill on a loose match).
+//
+// ENGINE subcommand gate: for an `engine.js` target we additionally require the
+// token AFTER the script to be `start`, so a short-lived `node engine.js stop`
+// one-shot (spawned by `minions restart`/`down`/`update` and the `stop` verb
+// during the restart window) is NEVER reaped. The long-lived daemon is ALWAYS
+// spawned with `'start'` (supervisor/dashboard spawnEngine + bin/minions.js), so
+// the requirement loses zero real orphans. The `dashboard.js` match stays BARE
+// (no subcommand) — only the engine candidate gets the `start` requirement.
 function _cmdRunsScript(cmdline, target) {
   const toks = _tokenizeCmdline(cmdline);
+  const isEngineTarget = target === 'engine.js' || target.endsWith('/engine.js');
   // toks[0] is the node executable; the script is the first later .js token.
   for (let i = 1; i < toks.length; i++) {
     const norm = _normPath(toks[i]);
-    if (norm.endsWith('.js')) return norm === target;
+    if (norm.endsWith('.js')) {
+      if (norm !== target) return false;
+      if (isEngineTarget) {
+        // Only the daemon (`engine.js start`) is reapable; one-shots like
+        // `engine.js stop` are left alone.
+        const next = toks[i + 1] ? _normPath(toks[i + 1]) : '';
+        return next === 'start';
+      }
+      return true;
+    }
   }
   return false;
 }

package/engine.js

@@ -1454,7 +1454,13 @@ async function assertCleanSharedWorktree(rootDir, worktreePath, branchName, disp
     return result;
   }
   if (statusOut) {
-    result.dirtyFiles = statusOut.split('\n').map(l => l.trim()).filter(Boolean);
+    result.dirtyFiles = statusOut.split('\n').map(l => l.trim()).filter(Boolean)
+      // #284: the engine's own .minions-worktree ownership marker can surface
+      // as an untracked entry when the checked-out tree predates the .gitignore
+      // line that excludes it (or it's a foreign repo). An untracked marker
+      // alone is a CLEAN tree for reuse — never let the engine fail/quarantine
+      // a work item over an artifact it stamped itself.
+      .filter(l => !shared.isWorktreeOwnerMarkerStatusLine(l));
   }
   const filesystemDirty = result.dirtyFiles.length > 0;
 
@@ -1597,9 +1603,15 @@ async function assertCleanSharedWorktree(rootDir, worktreePath, branchName, disp
   try {
     const r2 = await execAsync(_statusPorcelainCmd(), { ...gitOpts, cwd: worktreePath, timeout: statusTimeoutMs });
     const after = (r2 || '').toString().trim();
-    if (after) {
+    // #284: ignore the ownership marker here too — `git clean -fd` removes it,
+    // but the engine may re-stamp it, and it must never count as residual dirt.
+    const afterFiles = after
+      ? after.split('\n').map(l => l.trim()).filter(Boolean)
+        .filter(l => !shared.isWorktreeOwnerMarkerStatusLine(l))
+      : [];
+    if (afterFiles.length) {
       result.reason = 'dirty-after-clean';
-      result.dirtyFiles = after.split('\n').map(l => l.trim()).filter(Boolean);
+      result.dirtyFiles = afterFiles;
       return result;
     }
   } catch (e) {
@@ -2831,6 +2843,18 @@ async function spawnAgent(dispatchItem, config) {
         const failureClassName = isQuarantineEnvBlocked
           ? 'WORKTREE_QUARANTINE_ENV_BLOCKED'
           : (isDivergent ? 'WORKTREE_DIVERGENT' : 'WORKTREE_DIRTY');
+        // #284: distinguish the ORIGINAL worktree-preflight failure from a
+        // failure on the automatic fresh-worktree retry. The quarantine
+        // auto-recovery loop (discoverFromWorkItems) flips a failed
+        // WORKTREE_DIRTY/DIVERGENT item back to pending and stamps
+        // _quarantineRecoveryCount on the WI; if this dispatch (a re-dispatch
+        // of that item) hits the preflight gate AGAIN, the fresh worktree did
+        // not resolve the dirt — surface that in the completion report so a
+        // human/the engine can tell the two apart.
+        const priorQuarantineRetry = Number(meta?.item?._quarantineRecoveryCount) || 0;
+        const retryLabel = priorQuarantineRetry > 0
+          ? ` [retry-in-fresh-worktree #${priorQuarantineRetry} also failed]`
+          : ' [original worktree-preflight issue]';
         const reasonMsg = cleanResult.quarantined
           ? `${failureClassName}: reused worktree at ${worktreePath} was dirty/divergent (${cleanResult.reason}; ${cleanResult.ahead || 0} ahead, ${cleanResult.behind || 0} behind, ${cleanResult.dirtyFiles?.length || 0} dirty file(s)${previewFiles ? ': ' + previewFiles : ''}) — quarantined to ${cleanResult.quarantinedPath}. Next dispatch will start fresh.`
           : `${failureClassName}: reused worktree at ${worktreePath} is dirty/divergent (${cleanResult.reason}; ${cleanResult.ahead || 0} ahead, ${cleanResult.behind || 0} behind, ${cleanResult.dirtyFiles?.length || 0} file(s)${previewFiles ? ': ' + previewFiles : ''}). Quarantine ${cleanResult.quarantineError ? 'errored: ' + cleanResult.quarantineError : (cleanResult.quarantineSkipped ? 'was skipped — another live dispatch claims the worktree (see notes/inbox/ engine-worktree-skip-live note).' : 'was not attempted (' + cleanResult.reason + ').')}`;
@@ -2840,7 +2864,7 @@ async function spawnAgent(dispatchItem, config) {
           id,
           DISPATCH_RESULT.ERROR,
           reasonMsg.slice(0, 500),
-          `Engine preflight refused to dispatch into a dirty/divergent reused worktree (#2996). Reason: ${cleanResult.reason}.${cleanResult.quarantined ? ` Worktree quarantined to ${cleanResult.quarantinedPath}; backup ref ${cleanResult.backupRef || '(skipped)'}. See notes/inbox/ for recovery instructions.` : (cleanResult.quarantineSkipped ? ' Quarantine was skipped because another live dispatch claims this worktree path; this dispatch will not auto-retry until the live claimant clears.' : '')}${isQuarantineEnvBlocked ? ' Environmental quarantine failure (Windows EBUSY); WI auto-recovery loop will re-queue without bumping per-agent retry counter.' : ''}`,
+          `Engine preflight refused to dispatch into a dirty/divergent reused worktree (#2996).${retryLabel} Reason: ${cleanResult.reason}.${cleanResult.quarantined ? ` Worktree quarantined to ${cleanResult.quarantinedPath}; backup ref ${cleanResult.backupRef || '(skipped)'}. See notes/inbox/ for recovery instructions.` : (cleanResult.quarantineSkipped ? ' Quarantine was skipped because another live dispatch claims this worktree path; this dispatch will not auto-retry until the live claimant clears.' : '')}${isQuarantineEnvBlocked ? ' Environmental quarantine failure (Windows EBUSY); WI auto-recovery loop will re-queue without bumping per-agent retry counter.' : ''}`,
           { agentRetryable: isStatusProbeFailed && cleanResult.quarantined, failureClass: failureClassValue },
         );
         cleanupTempAgent(agentId);
@@ -3347,8 +3371,12 @@ async function spawnAgent(dispatchItem, config) {
     try {
       const dirtyResult = await execAsync(_statusPorcelainCmd(), { ..._gitOpts, cwd: worktreePath, timeout: 10000 });
       const dirtyOutput = (dirtyResult.stdout || '').trim();
-      if (dirtyOutput) {
-        const dirtyFiles = dirtyOutput.split('\n').map(l => l.trim()).filter(Boolean);
+      const dirtyFiles = dirtyOutput
+        ? dirtyOutput.split('\n').map(l => l.trim()).filter(Boolean)
+          // #284: don't surface the engine's own ownership marker as "prior work".
+          .filter(l => !shared.isWorktreeOwnerMarkerStatusLine(l))
+        : [];
+      if (dirtyFiles.length) {
         const dirtySection = [
           '\n## Uncommitted Work in Worktree\n',
           'The worktree has uncommitted changes from a previous agent run. Review these files and continue from where the previous agent left off.\n',
@@ -8704,8 +8732,16 @@ async function discoverWork(config) {
           // readdir and read (e.g. concurrent archive), do not resurrect it
           // from a stale .backup sidecar (W-mouptdh1000h9f39).
           const plan = safeJsonNoRestore(path.join(prdDir, f));
-          if (!plan?.missing_features || plan.status === PLAN_STATUS.COMPLETED) {
-            if (plan?.status === PLAN_STATUS.COMPLETED) completedPlanCache.add(f);
+          if (!plan?.missing_features) continue;
+          // A completed PRD may still be missing its aggregate verify WI — e.g. it
+          // landed on disk pre-completed via the plan-to-prd / pipeline path, so no
+          // agent-completion event ever drove checkPlanCompletion (W-mqk5ld3p). The
+          // function is idempotent (re-checks for an existing verify WI under lock),
+          // so run it for completed plans too and cache only once it reports nothing
+          // left to do (truthy return).
+          if (plan.status === PLAN_STATUS.COMPLETED) {
+            const done = lifecycle.checkPlanCompletion({ item: { sourcePlan: f } }, config);
+            if (done) completedPlanCache.add(f);
             continue;
           }
           if (plan.status !== PLAN_STATUS.APPROVED && plan.status !== PLAN_STATUS.ACTIVE) continue;
@@ -9258,11 +9294,13 @@ async function tickInner() {
           continue;
         }
         const plan = safeJson(path.join(PRD_DIR, file));
-        if (plan && plan.missing_features && plan.status !== PLAN_STATUS.COMPLETED) {
+        if (plan && plan.missing_features) {
+          // Run for completed PRDs too — a pre-completed plan (flag already set,
+          // items pre-marked done) still needs its aggregate verify gate created.
+          // checkPlanCompletion is idempotent; cache only once it reports nothing
+          // left to do (truthy return) (W-mqk5ld3p).
           const completed = checkPlanCompletion({ item: { sourcePlan: file } }, config);
           if (completed) completedPlanCache.add(file);
-        } else if (plan?.status === PLAN_STATUS.COMPLETED) {
-          completedPlanCache.add(file);
         }
       }
     } catch (err) { log('warn', `Plan completion check error: ${err?.message || err}`); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2227",
+  "version": "0.1.2229",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"

package/playbooks/shared-rules.md

@@ -153,7 +153,11 @@ Copyable worked example:
 
 Entries you report are **cross-checked** against what the engine propagated into your worktree and annotated `grounded: true | false` — never dropped — so a `grounded: false` entry surfaces a discrepancy for a human rather than being hidden. Full contract: `docs/harness-transparency.md`.
 
-When you author a **PR review / fix summary comment** (GitHub `minions pr comment` / `gh pr comment`, or Azure DevOps `az repos pr comment`), fold the same harness footprint into the body as a collapsible section so reviewers see which skills / MCPs / docs informed the change. Render it **identically on both hosts** — append this exact `<details>` block at the end of your comment body (omit it entirely when you used no affordances):
+When you author a **PR review / fix summary comment**, the same harness footprint belongs in the comment body as a collapsible "Harnesses used" section so reviewers see which skills / MCPs / docs informed the change.
+
+**Preferred — `minions pr comment` (GitHub and Azure DevOps `--host ado`): do NOT hand-render the section.** Write your `harnessUsed` record — the same `{ skills, mcpServers, commands, docs }` shape as the completion field above — to a JSON file and pass `--harness-file <path>` (or inline via `--harness-json <json>`). The shared builder (`engine/comment-format.js#buildHarnessUsedSection`, consumed by both `engine/gh-comment.js` and `engine/ado-comment.js`) folds the byte-identical `<details>` section into the body for you, so agent-authored and engine-authored comments match. Each entry is cross-checked against the harness manifest the engine propagated into your worktree and annotated `grounded: true | false` (never dropped); a `grounded: false`, ⚠️-marked bullet means **the engine couldn't confirm that affordance against the propagated manifest — not that you did anything wrong**.
+
+**Raw fallbacks only — `gh pr comment` / `az repos pr comment` / ADO REST:** these bypass the CLI chokepoint, so you MUST hand-render the section yourself. Render it **identically on both hosts** — append this exact `<details>` block at the end of your comment body (omit it entirely when you used no affordances):
 
 ```markdown
 <details>
@@ -167,7 +171,7 @@ When you author a **PR review / fix summary comment** (GitHub `minions pr commen
 </details>
 ```
 
-One bullet per affordance, in the order skills → MCP servers → commands → docs; `N` is the bullet count. This is the human-readable mirror of your `harnessUsed` completion field — keep the two consistent. The engine renders the byte-identical section via `engine/comment-format.js#buildHarnessUsedSection` when it composes a comment, so agent-authored and engine-authored sections match.
+One bullet per affordance, in the order skills → MCP servers → commands → docs; `N` is the bullet count. Whether the CLI folds it in or you hand-render it on a raw fallback, the section is the human-readable mirror of your `harnessUsed` completion field — keep the two consistent.
 
 ## Minions API access