@yemi33/minions 0.1.2197 → 0.1.2199

package/dashboard/js/command-center.js

@@ -1447,11 +1447,41 @@ function _ccActionResultLine(action, result) {
   }
   if (result && result.ok) {
     var duplicate = result.duplicate ? ' <span style="color:var(--orange)">already exists</span>' : '';
-    return '<div class="cc-action-feedback-chip" style="' + CC_ACTION_CHIP_STYLE + ';color:var(--green)">&#10003; ' + label + duplicate + '</div>';
+    var chip = '<div class="cc-action-feedback-chip" style="' + CC_ACTION_CHIP_STYLE + ';color:var(--green)">&#10003; ' + label + duplicate + '</div>';
+    // P-ppa10004: a successful pr-action carries follow-up affordances
+    // ([Comment] [Fix once] [Track for auto-fix]); render them as clickable
+    // chips that send a templated CC turn.
+    var followups = (result && result.followups) || (action && action.followups);
+    return chip + _ccFollowupChips(followups);
   }
   return '';
 }
 
+// Render follow-up action chips (P-ppa10004). Each chip click sends its
+// templated CC message as a fresh turn via ccPrActionFollowup.
+function _ccFollowupChips(followups) {
+  if (!Array.isArray(followups) || followups.length === 0) return '';
+  var btns = followups.map(function(f) {
+    if (!f || !f.label || !f.message) return '';
+    return '<button type="button" class="cc-followup-chip" onclick="ccPrActionFollowup(' + _ccJsArg(f.message) + ')" ' +
+      'style="padding:3px 10px;border-radius:4px;font-size:var(--text-sm);border:1px solid var(--border);background:var(--surface2);color:var(--blue);cursor:pointer">' +
+      escHtml(f.label) + '</button>';
+  }).filter(Boolean).join('');
+  if (!btns) return '';
+  return '<div class="cc-followup-chips" style="margin:4px 0 0 0;display:flex;flex-wrap:wrap;gap:6px">' + btns + '</div>';
+}
+
+// Click handler for a follow-up action chip: drop the templated message into
+// the input and send it as a normal CC turn (so the user sees their intent and
+// CC routes it — forward-compatible with the Phase 2/3 flows).
+function ccPrActionFollowup(message) {
+  if (!message) return;
+  var input = document.getElementById('cc-input');
+  if (!input) return;
+  input.value = String(message);
+  ccSend();
+}
+
 
 function _ccAppendHtmlToMessage(tabOrId, messageId, html) {
   if (!messageId || !html) return false;
@@ -2163,4 +2193,4 @@ if (document.readyState === 'loading') {
   ccInitResize();
 }
 
-window.MinionsCC = { toggleCommandCenter, ccNewSession, ccNewTab, ccSwitchTab, ccCloseTab, ccRenderTabBar, ccRestoreMessages, ccSaveState, ccUpdateSessionIndicator, ccAddMessage, ccSend, ccAbort, ccExecuteAction };
+window.MinionsCC = { toggleCommandCenter, ccNewSession, ccNewTab, ccSwitchTab, ccCloseTab, ccRenderTabBar, ccRestoreMessages, ccSaveState, ccUpdateSessionIndicator, ccAddMessage, ccSend, ccAbort, ccExecuteAction, ccPrActionFollowup };

package/dashboard.js

@@ -42,6 +42,10 @@ const { wrapUntrusted, buildSource } = require('./engine/untrusted-fence');
 const steering = require('./engine/steering');
 const steeringStore = require('./engine/steering-store');
 const projectDiscovery = require('./engine/project-discovery');
+const prAction = require('./engine/pr-action');
+const prResolve = require('./engine/pr-resolve');
+const prFixTarget = require('./engine/pr-fix-target');
+const prTrack = require('./engine/pr-track');
 const features = require('./engine/features');
 const ccWorkerPool = require('./engine/cc-worker-pool');
 const diagnosticsMemory = require('./engine/diagnostics-memory');
@@ -3404,6 +3408,9 @@ function _buildSyntheticActionResultsForTurn(turnId, message, requestedAt) {
     };
     if (entry.project) action.project = entry.project;
     if (entry.path) action.path = entry.path;
+    // P-ppa10004: pr-action chips carry follow-up affordances ([Comment]
+    // [Fix once] [Track for auto-fix]) so the renderer can offer the next step.
+    if (Array.isArray(entry.followups) && entry.followups.length) action.followups = entry.followups;
     actions.push(action);
     const result = {
       ok: true,
@@ -3419,6 +3426,7 @@ function _buildSyntheticActionResultsForTurn(turnId, message, requestedAt) {
     if (entry.id) result.id = entry.id;
     if (entry.project) result.project = entry.project;
     if (entry.path) result.path = entry.path;
+    if (Array.isArray(entry.followups) && entry.followups.length) result.followups = entry.followups;
     results.push(result);
   }
   return { actions, results };
@@ -3435,6 +3443,7 @@ function _ccTurnEntryToActionType(kind) {
     case 'pipeline-run': return 'trigger-pipeline';
     case 'watch': return 'create-watch';
     case 'meeting': return 'create-meeting';
+    case 'pr-action': return 'pr-action';
     default: return kind;
   }
 }
@@ -3949,14 +3958,6 @@ function getWorkItemPrRef(input) {
   return shared.extractWorkItemPrRef(input);
 }
 
-function isPrTargetedWorkType(workType) {
-  return ['fix', 'review', 'test'].includes(String(workType || '').toLowerCase());
-}
-
-function trimTrailingPrRefPunctuation(value) {
-  return String(value || '').replace(/[),.;:]+$/g, '');
-}
-
 // ── Shared LLM call core — used by CC panel and doc modals ──────────────────
 
 // Session store for doc modals — keyed by filePath or title, persisted to disk.
@@ -12606,6 +12607,92 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       })();
     }},
 
+    { method: 'POST', path: '/api/pr-action', desc: 'User-initiated read-only action on any GitHub/ADO PR URL (no project/clone required). Resolves the PR via the projectless resolver. Default: returns an observable dispatch handle. With `execute:true`: runs the read-only action now (fetch → fence → DIRECT LLM) and returns its output plus follow-up action chips ([Comment] [Fix once] [Track for auto-fix]). Read-only only — no auto-polling/discovery.', params: 'url (PR URL or canonical id), action (review|summarize|comment|triage), execute (optional bool — run now and return output + follow-up chips)', handler: async (req, res) => {
+      const body = await readBody(req);
+      try {
+        if (body && body.execute) {
+          reloadConfig();
+          const record = await prAction.runPrAction({ url: body?.url, action: body?.action }, { engineConfig: CONFIG.engine });
+          const followups = record.status === 'done' ? prAction.buildPrActionFollowups(record, { prUrl: body?.url }) : [];
+          recordCcTurnIfPresent(req, { kind: 'pr-action', id: record.id, title: `${record.action} ${record.prId || ''}`.trim(), followups });
+          return jsonReply(res, 200, { ok: record.status !== 'failed', ...record, followups }, req);
+        }
+        const handle = await prAction.createPrAction({ url: body?.url, action: body?.action });
+        recordCcTurnIfPresent(req, { kind: 'pr-action', id: handle.id, title: `${handle.action} ${handle.prId || ''}`.trim() });
+        return jsonReply(res, 200, { ok: true, ...handle }, req);
+      } catch (e) {
+        return jsonReply(res, e.statusCode || 400, { error: e.message }, req);
+      }
+    }},
+
+    { method: 'POST', path: '/api/pr-action/fix', desc: 'Plan a one-off fix on any GitHub/ADO PR URL (Phase 2, P-ppa10005 — decision/routing surface only). Without `target`: returns the execution-target choice. If the PR’s repo is already a configured project, returns {status:"project-ready"} (skip the prompt, use the existing project fix path); otherwise {status:"awaiting-target-choice"} with options [clone-keep, temp-clone (default), remote-patch, devbox] plus a CC prompt + dashboard modal — NOTHING is cloned. With `target`: validates the choice and returns the routing intent {status:"routed", executor} to the matching executor. temp-clone (default) is implemented in engine/pr-temp-clone.js (executor.module:"pr-temp-clone"), clone-keep in engine/pr-clone-keep.js (executor.module:"pr-clone-keep", auto-clone + persistent project registration), remote-patch in engine/pr-remote-patch.js (executor.module:"pr-remote-patch", GitHub Contents API single-file edit, NO clone and NO validation — GitHub-only), and devbox in engine/pr-devbox.js (executor.module:"pr-devbox", P-ppa10011 stretch — ephemeral clone+fix+push ON A DEVBOX, zero local footprint, never auto-selected). Never clones silently. P-ppa10009: pass `remember:true` alongside `target` to remember the choice per repo so subsequent fixes on that repo skip the prompt; a remembered choice makes the no-`target` call return {status:"routed", fromRemembered:true} instead of prompting. Pass `reprompt:true` to force the prompt despite a remembered choice (override). Clear a remembered choice via POST /api/pr-action/fix-target/forget.', params: 'url (PR URL or canonical id), target (optional — clone-keep|temp-clone|remote-patch|devbox), remember (optional bool — persist target per repo), reprompt (optional bool — force the choice despite a remembered one)', handler: async (req, res) => {
+      const body = await readBody(req);
+      try {
+        reloadConfig();
+        if (body && body.target != null && body.target !== '') {
+          // `remember:true` persists this choice per repo so future fixes skip
+          // the prompt (P-ppa10009).
+          const routed = prFixTarget.resolvePrFixTarget({ url: body?.url }, body.target, { config: CONFIG, remember: !!body.remember });
+          recordCcTurnIfPresent(req, { kind: 'pr-action', id: routed.prId || '', title: `fix ${routed.prId || ''} → ${routed.target}`.trim() });
+          return jsonReply(res, 200, { ok: true, ...routed }, req);
+        }
+        // `reprompt:true` forces the execution-target prompt even when a per-repo
+        // choice is remembered (the override path for P-ppa10009).
+        const plan = prFixTarget.planPrFix({ url: body?.url }, { config: CONFIG, prUrl: body?.url, ignoreRemembered: !!body?.reprompt });
+        recordCcTurnIfPresent(req, { kind: 'pr-action', id: plan.prId || '', title: `fix ${plan.prId || ''} (${plan.status})`.trim() });
+        return jsonReply(res, 200, { ok: true, ...plan }, req);
+      } catch (e) {
+        return jsonReply(res, e.statusCode || 400, { error: e.message }, req);
+      }
+    }},
+
+    { method: 'POST', path: '/api/pr-action/fix-target/forget', desc: 'Clear/override the remembered per-repo execution-target choice (Phase 3, P-ppa10009). Given a PR `url` (or canonical id), forgets the remembered clone-keep|temp-clone|remote-patch choice for that repo scope so the next fix re-prompts. Returns {cleared:true} if a remembered choice existed, {cleared:false} otherwise.', params: 'url (PR URL or canonical id)', handler: async (req, res) => {
+      const body = await readBody(req);
+      try {
+        const ref = prResolve.normalizePrRef(typeof body?.url === 'string' ? body.url.trim() : '');
+        if (!ref) return jsonReply(res, 400, { error: `unrecognized PR reference: ${JSON.stringify(String(body?.url || '').slice(0, 120))}` }, req);
+        const cleared = prFixTarget.clearRememberedTargetForRef(ref);
+        recordCcTurnIfPresent(req, { kind: 'pr-action', id: ref.id || '', title: `forget fix target ${ref.id || ''}`.trim() });
+        return jsonReply(res, 200, { ok: true, cleared, prId: ref.id || null }, req);
+      } catch (e) {
+        return jsonReply(res, e.statusCode || 400, { error: e.message }, req);
+      }
+    }},
+
+    { method: 'POST', path: '/api/pr-action/track', desc: 'Promote a one-off PR to TRACKED auto-fix (Phase 3, P-ppa10010 — enrollment wiring). If the PR’s repo is NOT a configured project, returns {status:"awaiting-target-choice"} with options [clone-keep (recommended for ongoing tracking), temp-clone, remote-patch] + a CC prompt and dashboard modal — NOTHING is cloned (pick "clone-keep" via POST /api/pr-action/fix to register a persistent project, then call this again to finish enrollment). If the repo IS a configured project, enrolls the PR via the manual-link path with contextOnly:false (the canonical shared.isAutoManagedPrRecord signal) and returns {status:"enrolled", autoManaged:true}. From enrollment on the EXISTING pollers/discoverFromPrs → review/fix/re-review → auto-merge pipeline runs unchanged — no new fix engine.', params: 'url (PR URL or canonical id)', handler: async (req, res) => {
+      const body = await readBody(req);
+      try {
+        reloadConfig();
+        const plan = prTrack.planPrTrack({ url: body?.url }, { config: CONFIG, prUrl: body?.url });
+        if (plan.status === 'awaiting-target-choice') {
+          // Unconfigured repo — ongoing tracking needs a persistent checkout, so
+          // pause for the Clone & keep choice. NOTHING is cloned/enrolled yet.
+          recordCcTurnIfPresent(req, { kind: 'pr-action', id: plan.prId || '', title: `track ${plan.prId || ''} (${plan.status})`.trim() });
+          return jsonReply(res, 200, { ok: true, ...plan }, req);
+        }
+        // project-ready: enroll via the existing manual-link path. Linking with
+        // contextOnly:false creates the record if missing and PROMOTES an existing
+        // context-only record to auto-managed (upsert refuses to demote a managed
+        // PR). No new engine — the existing pipeline discovers it next tick.
+        const enrollment = prTrack.buildTrackEnrollment(plan, { prUrl: body?.url });
+        const linkResult = linkPullRequestForTracking({ url: enrollment.url, contextOnly: enrollment.contextOnly }, CONFIG);
+        invalidateStatusCache();
+        const autoManaged = shared.isAutoManagedPrRecord(linkResult.record);
+        recordCcTurnIfPresent(req, { kind: 'pr-action', id: linkResult.id, title: `track ${linkResult.id} → auto-fix`.trim() });
+        return jsonReply(res, 200, {
+          ok: true,
+          status: 'enrolled',
+          prId: linkResult.id,
+          autoManaged,
+          contextOnly: false,
+          project: linkResult.targetProject?.name || 'central',
+          projectName: plan.projectName || linkResult.targetProject?.name || null,
+        }, req);
+      } catch (e) {
+        return jsonReply(res, e.statusCode || 400, { error: e.message }, req);
+      }
+    }},
+
     { method: 'POST', path: '/api/pull-requests/observe', desc: 'Toggle canonical contextOnly flag on a tracked PR (public `observe` body param is preserved as the inverse for backward compat)', params: 'host (github|ado), slug, number, observe (boolean)', handler: async (req, res) => {
       const body = await readBody(req);
       reloadConfig();

package/docs/README.md

@@ -21,15 +21,18 @@ Architecture, design proposals, and lifecycle references for people working on t
 - [constellation-style-telemetry.md](constellation-style-telemetry.md) — Feasibility study (design proposal, not implemented) for a local-first usage/analytics layer modelled on Constellation's telemetry stack — typed append-only event log + retention/rollup discipline + dashboard Usage page. Explains why a 1:1 PostgreSQL/multi-tenant port is the wrong goal for Minions.
 - [cooldown-merge-semantics.md](cooldown-merge-semantics.md) — Scoping deliverable defining merge semantics for `saveCooldowns` (longer-of TTL merge, key-level upserts, gitignored on-disk format).
 - [copilot-cli-schema.md](copilot-cli-schema.md) — Behavior and schema reference for the GitHub Copilot CLI adapter (capability flags, stdin vs `-p`, model discovery, effort levels).
+- [cross-repo-plans.md](cross-repo-plans.md) — Cross-repo plans: a single plan whose work items ship into two or more configured projects — per-item `project` field, per-project work-item fan-out, and one verify work item per touched repo.
 - [dead-code-audit-retractions.md](dead-code-audit-retractions.md) — Retracted dead-code-audit findings (false positives) that future audits MUST read before re-citing.
 - [deprecated-process.md](deprecated-process.md) — Schema for `docs/deprecated.json` and the weekly `cleanup-deprecated` audit walk that retires entries past their removal signal.
 - [design-state-storage.md](design-state-storage.md) — Design proposal evaluating five database options for replacing Minions' file-based JSON state; recommends `node:sqlite` as the medium-term target (accepted; implementation tracked in CHANGELOG.md Phases 0–9).
 - [harness-mode.md](harness-mode.md) — Tri-Agent Harness Mode (`harness_mode: "tri_agent"` on scheduled tasks): Planner → Generator → Evaluator loop that iterates a shared on-disk artifact until a rubric passes or the iteration cap fires.
+- [harness-propagation.md](harness-propagation.md) — How user-level and project-local harness assets (skills, slash-commands, MCP config, `CLAUDE.md` / `AGENTS.md`) propagate into an agent's worktree via `--add-dir`, the `harnessPropagateProjectLocal` flag, and the project-local-on-main worktree-visibility footgun.
 - [kb-sweep.md](kb-sweep.md) — Knowledge-base consolidation sweep (hash dedup → LLM batch dedup/reclassify → per-entry compress) and the detached runner that keeps it alive across `minions restart`.
 - [keep-processes.md](keep-processes.md) — `meta.keep_processes` sidecar contract: when to use it vs managed-spawn, sidecar schema, caps, and the [`engine/keep-process-sweep.js`](../engine/keep-process-sweep.js) lifecycle.
 - [live-checkout-mode.md](live-checkout-mode.md) — Per-project opt-in `worktreeMode: 'live'`: skips `git worktree add` and dispatches in-place inside `project.localPath` for `repo`-managed trees, submodule-heavy repos, deep Windows paths, and native build state. Includes the refuse-on-dirty contract and the per-project mutating-concurrency cap of 1.
 - [managed-spawn.md](managed-spawn.md) — Engine-owned long-running services (managed-spawn primitive): sidecar schema, healthcheck examples, lifecycle, dashboard API, and the WI 1 (build) → WI 2 (test) chained-validation pattern.
 - [plan-lifecycle.md](plan-lifecycle.md) — Full plan pipeline from `/plan` through PRD materialization, dispatch with dependency gating, verify task, and human archive.
+- [pr-auto-fix-dispatch.md](pr-auto-fix-dispatch.md) — Short reference table mapping each PR auto-fix / review dispatch site in `engine.js#discoverFromPrs` to its gate flag, plus the `pollingPaused` / `autoFixPaused` master kill-switches and the per-provider polling gates.
 - [pr-comment-followup.md](pr-comment-followup.md) — PR-comment follow-up dispatch contract: fix/review agents may spin off a new WI via `POST /api/work-items` with `meta.pr_followup` instead of broadening the current PR or rebutting the comment.
 - [pr-review-fix-loop.md](pr-review-fix-loop.md) — How the engine moves a PR from creation through review, fix dispatch, and re-review, including stale-status guards.
 - [project-skills.md](project-skills.md) — Project-local skill discovery (`.claude/skills/`, `.claude/commands/`, `CLAUDE.md` / `.github/copilot-instructions.md` slash-command mentions): how dispatched agents see and steer toward purpose-built tooling the project ships, plus the intent-vocabulary contract.

package/engine/db/migrations/014-pr-fix-target-prefs.js

@@ -0,0 +1,29 @@
+// engine/db/migrations/014-pr-fix-target-prefs.js
+//
+// Plan: projectless-pr-actions, Phase 3, item P-ppa10009 — "Remember
+// execution-target choice per repo (optional)".
+//
+// Adds the `pr_fix_target_prefs` table — one row per repo scope — so the
+// execution-target choice surface (engine/pr-fix-target.js) can OPTIONALLY
+// remember the user's pick (clone-keep | temp-clone | remote-patch) keyed by
+// canonical PR scope (github:owner/repo / ado:org/proj/repo). When a remembered
+// choice exists, a repeat fix on that repo routes straight to the executor
+// instead of re-prompting. Absence of a row still prompts (the safe default —
+// never clone silently). The choice is clearable/overridable.
+//
+// SQL-first per CLAUDE.md "New state goes into SQL first" — no JSON sidecar;
+// reads/writes go through engine/pr-fix-target-store.js.
+
+module.exports = {
+  version: 14,
+  description: 'pr_fix_target_prefs: remembered per-repo execution-target choices',
+  up(db) {
+    db.exec(`
+      CREATE TABLE pr_fix_target_prefs (
+        repo_scope   TEXT PRIMARY KEY,
+        target       TEXT NOT NULL,
+        updated_at   INTEGER NOT NULL
+      );
+    `);
+  },
+};

package/engine/gh-token.js

@@ -109,6 +109,35 @@ function resolveTokenForSlug(slug, opts = {}) {
   return _fetchTokenForAccount(account, opts);
 }
 
+/**
+ * Resolve a GitHub PAT for a named account directly (bypassing slug→account
+ * mapping). Used by the projectless PR resolver's unknown-slug fallback
+ * (engine/pr-resolve.js) to try each authed account in turn WITHOUT touching
+ * the global active `gh auth` profile. Returns the token string or null.
+ */
+function tokenForAccount(account, opts = {}) {
+  return _fetchTokenForAccount(account, opts);
+}
+
+/**
+ * List the distinct gh account names configured in `engine.ghAccounts`. This is
+ * the candidate set the unknown-slug fallback iterates over (per the plan:
+ * "fall back across the available authed accounts" rather than relying on the
+ * active `gh auth` profile). Order follows the config object's own key order.
+ */
+function listConfiguredAccounts(opts = {}) {
+  const config = _readConfig(opts);
+  const accounts = (config && config.engine && config.engine.ghAccounts) || {};
+  if (!accounts || typeof accounts !== 'object') return [];
+  const seen = new Set();
+  const out = [];
+  for (const value of Object.values(accounts)) {
+    const name = value == null ? '' : String(value);
+    if (name && !seen.has(name)) { seen.add(name); out.push(name); }
+  }
+  return out;
+}
+
 /** Test-only: prime a slug→token override that bypasses config + shell-out. */
 function _setTokenForTest(slug, token) {
   if (!slug) return;
@@ -127,6 +156,8 @@ function _clearTokenCache() {
 module.exports = {
   resolveTokenForSlug,
   resolveAccountForSlug,
+  tokenForAccount,
+  listConfiguredAccounts,
   _setTokenForTest,
   _clearTokenCache,
   // Constants exposed for tests + diagnostics.