@yemi33/minions 0.1.2216 → 0.1.2218

package/dashboard.js

@@ -13033,6 +13033,36 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       }
     }},
 
+    { method: 'POST', path: '/api/pr-action/offer-create-pr', desc: 'Offer a "Create PR" follow-up chip after Command Center makes a LOCAL code edit itself in a configured project (P-cc-createpr). Validates the project has uncommitted working-tree changes (git status --porcelain in project.localPath) and returns a create-pr follow-up chip — same CC-mediated shape as the pr-action chips, so the existing dashboard chip renderer/click handler light up unchanged. Returns {ok, hasChanges, branch, changedFileCount, followups}; followups is [] when there is nothing to PR. READ-ONLY: never stages/commits/pushes — clicking the chip routes a fresh CC turn that does the commit/push/PR-create/link.', params: 'project (configured project name), branch (optional — defaults to the working-tree current branch), contextOnly (optional bool — link the new PR as context-only instead of auto-managed)', handler: async (req, res) => {
+      const body = await readBody(req);
+      try {
+        reloadConfig();
+        const projectName = typeof body?.project === 'string' ? body.project.trim() : '';
+        if (!projectName) return jsonReply(res, 400, { error: 'project is required' }, req);
+        const project = shared.getProjects(CONFIG).find(p => p && p.name === projectName);
+        if (!project) return jsonReply(res, 404, { error: `unknown project: ${projectName}` }, req);
+        if (!project.localPath) return jsonReply(res, 400, { error: `project ${projectName} has no localPath (no working tree to PR)` }, req);
+        let porcelain = '';
+        let currentBranch = '';
+        try {
+          porcelain = await shared.shellSafeGit(['-C', project.localPath, 'status', '--porcelain']);
+          currentBranch = (await shared.shellSafeGit(['-C', project.localPath, 'rev-parse', '--abbrev-ref', 'HEAD'])).trim();
+        } catch (e) {
+          return jsonReply(res, 400, { error: `git status failed for ${projectName}: ${e.message}` }, req);
+        }
+        const changedFileCount = porcelain.split('\n').map(s => s.trim()).filter(Boolean).length;
+        const hasChanges = changedFileCount > 0;
+        const branch = (typeof body?.branch === 'string' && body.branch.trim()) || currentBranch || '';
+        const followups = hasChanges
+          ? prAction.buildCreatePrFollowups({ project: projectName, branch, contextOnly: !!body?.contextOnly })
+          : [];
+        recordCcTurnIfPresent(req, { kind: 'pr-action', id: '', title: `offer create-pr (${projectName})`, project: projectName, followups });
+        return jsonReply(res, 200, { ok: true, hasChanges, branch, changedFileCount, followups }, 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/engine/cli.js

@@ -1255,7 +1255,10 @@ const commands = {
     }
     const control = getControl();
     if (control.pid && control.pid !== process.pid) {
-      try { process.kill(control.pid); } catch { /* process may be dead */ }
+      // killGracefully so the engine's SIGTERM graceful-shutdown handler runs
+      // and recurses into the child tree (bare process.kill defaults to a
+      // non-recursing SIGTERM that is Windows-broken — CLAUDE.md Footgun #4).
+      shared.killGracefully({ pid: control.pid });
     }
     mutateControl(() => ({ state: 'stopped', stopped_at: e.ts() }));
     e.log('info', 'Engine stopped');
@@ -1793,7 +1796,10 @@ const commands = {
       let pidNum = NaN;
       try { pidNum = shared.validatePid(raw); } catch { /* invalid — skip */ }
       if (pidNum > 0) {
-        try { process.kill(pidNum); console.log(`Killed process ${pidNum} (${fileName})`); }
+        // killImmediate force-kills the whole process tree (bare process.kill
+        // defaults to a non-recursing SIGTERM that is Windows-broken and
+        // leaks child processes — CLAUDE.md Footgun #4).
+        try { shared.killImmediate({ pid: pidNum }); console.log(`Killed process ${pidNum} (${fileName})`); }
         catch { console.log(`Process ${pidNum} already dead`); }
       } else {
         console.log(`Skipping ${fileName}: invalid or empty PID`);

package/engine/consolidation.js

@@ -541,7 +541,7 @@ function reconcileAndAppendToAgentMemory(item, knownAgents, config) {
         try { safeWrite(memPath + '.bak', beforeLock); }
         catch (err) { log('warn', `agent-memory reconcile: backup write failed for ${agent}: ${err.message}`); }
 
-        const next = pruneAgentMemoryToBudget(updated + entry, agent);
+        const next = pruneAgentMemoryToBudget(updated + entry, agent, _pruneOptsFromConfig(config));
         safeWrite(memPath, next);
         reconciled = true;
         const skippedCount = skipped.length;

package/engine/lifecycle.js

@@ -469,7 +469,7 @@ function archivePlan(planFile, plan, projects, config) {
       const mdFiles = fs.readdirSync(PLANS_DIR).filter(f => f.endsWith('.md'));
       for (const md of mdFiles) {
         const mdContent = shared.safeRead(path.join(PLANS_DIR, md)) || '';
-        if (mdContent.includes(projectName) || mdContent.includes(plan.plan_summary?.slice(0, 40) || '___nomatch___')) {
+        if ((projectName && mdContent.includes(projectName)) || mdContent.includes(plan.plan_summary?.slice(0, 40) || '___nomatch___')) {
           try {
             const mdDest = shared.moveFileNoClobber(path.join(PLANS_DIR, md), planArchiveDir, md);
             log('info', `Archived source plan: plans/archive/${path.basename(mdDest)}`);

package/engine/pipeline.js

@@ -126,6 +126,24 @@ function updateRunStage(pipelineId, runId, stageId, updates) {
   });
 }
 
+// Like updateRunStage, but creates the stage entry when the run never seeded it.
+// startRun only seeds top-level `pipeline.stages` ids; nested parallel sub-stages
+// live under `stage.stages`, so the run's `stages` map has no slot for them until
+// the parallel executor persists one. updateRunStage no-ops on a missing entry, so
+// the parallel path needs this upsert to make sub-stage state survive a disk
+// round-trip (without it the cross-tick PARALLEL completion check reads each sub
+// id as undefined forever and the parent wedges in RUNNING — P-9c1a4e7b).
+function upsertRunStage(pipelineId, runId, stageId, state) {
+  mutatePipelineRuns((data) => {
+    const runs = data[pipelineId] || [];
+    const run = runs.find(r => r.runId === runId);
+    if (!run) return data;
+    if (!run.stages || typeof run.stages !== 'object') run.stages = {};
+    run.stages[stageId] = { ...(run.stages[stageId] || {}), ...state };
+    return data;
+  });
+}
+
 function completeRun(pipelineId, runId, status) {
   // Stages whose status is in this set are considered "terminal" and must not
   // be touched by the run-close sweep. Anything else (RUNNING, PENDING,
@@ -829,12 +847,17 @@ function executeConditionStage(stage, stageState, run, pipeline, config) {
 
 async function executeParallelStage(stage, stageState, run, pipeline, config) {
   const subStages = stage.stages || [];
-  const subResults = {};
   for (const sub of subStages) {
     if (!run.stages[sub.id] || run.stages[sub.id].status === PIPELINE_STATUS.PENDING) {
       const result = await executeStage(sub, run, pipeline, config);
-      subResults[sub.id] = result;
-      run.stages[sub.id] = { ...run.stages[sub.id] || {}, ...result, startedAt: ts() };
+      const subState = { ...(run.stages[sub.id] || {}), ...result, startedAt: ts() };
+      run.stages[sub.id] = subState;
+      // Persist sub-stage state to disk. getActiveRun re-reads the run fresh from
+      // disk every tick, so a sub-stage mutated only on the in-memory run object is
+      // invisible to the next tick's PARALLEL completion check — the parent then
+      // wedges in RUNNING forever. updateRunStage only mutates an existing entry and
+      // sub-stage ids are never seeded by startRun, so upsert to seed + persist.
+      upsertRunStage(pipeline.id, run.runId, sub.id, subState);
     }
   }
   // Parent is running until all subs complete
@@ -966,9 +989,29 @@ function isStageComplete(stage, stageState, run, config) {
       return stageState.status === PIPELINE_STATUS.COMPLETED;
     case STAGE_TYPE.PARALLEL: {
       const subIds = artifacts.subStages || [];
+      if (subIds.length === 0) return true;
+      const subDefs = stage.stages || [];
       return subIds.every(id => {
-        const sub = run.stages[id];
-        return sub && (sub.status === PIPELINE_STATUS.COMPLETED || sub.status === PIPELINE_STATUS.FAILED);
+        const subState = run.stages[id];
+        if (!subState) return false; // sub-stage state not yet persisted — not complete
+        if (subState.status === PIPELINE_STATUS.COMPLETED || subState.status === PIPELINE_STATUS.FAILED) return true;
+        // Async sub-stages (task/meeting/plan/…) persist as RUNNING; their underlying
+        // work (work items, meetings, …) finishes on a later tick. The driver never
+        // re-executes a RUNNING parallel parent, so this completion check is the only
+        // place that advances them: evaluate each sub through its own completion logic
+        // and promote its persisted status so the run closes cleanly (no false
+        // non-terminal anomaly) and the dashboard reflects reality (P-9c1a4e7b).
+        const subDef = subDefs.find(s => s.id === id);
+        if (!subDef) return false;
+        if (isStageComplete(subDef, subState, run, config)) {
+          subState.status = PIPELINE_STATUS.COMPLETED;
+          subState.completedAt = subState.completedAt || ts();
+          updateRunStage(run.pipelineId, run.runId, id, {
+            status: PIPELINE_STATUS.COMPLETED, completedAt: subState.completedAt,
+          });
+          return true;
+        }
+        return false;
       });
     }
     default:

package/engine/pr-action.js

@@ -128,6 +128,50 @@ function buildPrActionFollowups(record, opts = {}) {
   }));
 }
 
+// ── "Create PR" follow-up (P-cc-createpr) ───────────────────────────────────
+// Offered after Command Center makes a LOCAL code edit itself (not via a
+// dispatched agent), so the user can open a PR for it with one click. Mirrors
+// the PR_ACTION_FOLLOWUPS chip shape ({ kind, label, message }) so the existing
+// dashboard renderer (_ccFollowupChips) + click handler (ccPrActionFollowup)
+// light up unchanged. CC-mediated by the same deliberate design as the
+// pr-action chips: clicking sends a fresh CC turn that commits/pushes/opens the
+// PR and links it to the tracker — no new server-side git path, maximal reuse.
+const CREATE_PR_FOLLOWUP = Object.freeze({ kind: 'create-pr', label: 'Create PR' });
+
+/**
+ * Build the "Create PR" follow-up chip(s) for a working-tree change CC just
+ * made in `project`. Returns `[]` when no project is given (nothing to act on).
+ *
+ * `branch`       — the working-tree branch to commit on; falls back to "a new
+ *                  well-named branch" wording when absent.
+ * `contextOnly`  — when true, the chip links the new PR as context-only instead
+ *                  of auto-managed (the default is auto-managed / contextOnly:false).
+ *
+ * Each chip: `{ kind:'create-pr', label, project, branch, message }` where
+ * `message` is the Command Center turn the chip click should send.
+ */
+function buildCreatePrFollowups({ project, branch, contextOnly = false } = {}) {
+  const proj = (project && String(project).trim()) || '';
+  if (!proj) return [];
+  const br = branch && String(branch).trim() ? String(branch).trim() : '';
+  const branchClause = br
+    ? `on the current branch ${br}`
+    : 'on a new well-named branch off the project main branch';
+  const linkBody = contextOnly
+    ? `{"url":"<new PR url>","project":"${proj}","contextOnly":true}`
+    : `{"url":"<new PR url>","project":"${proj}","contextOnly":false}`;
+  const trackNote = contextOnly
+    ? 'so it is tracked but not auto-reviewed'
+    : 'so the engine auto-manages it (review -> fix -> re-review -> auto-merge)';
+  const message =
+    `Create a PR from the local changes you just made in the ${proj} project. ` +
+    `Steps: (1) in that project's working tree, stage and commit the modified files ${branchClause} with a clear conventional-commit message; ` +
+    `(2) push the branch; (3) open a PR against the project's main branch using the right CLI for the repo host (gh for GitHub, az repos for ADO); ` +
+    `(4) link it to the tracker by calling POST /api/pull-requests/link with ${linkBody} ${trackNote}. ` +
+    `Then show me the PR URL.`;
+  return [{ kind: CREATE_PR_FOLLOWUP.kind, label: CREATE_PR_FOLLOWUP.label, project: proj, branch: br || null, message }];
+}
+
 // Read-only system prompt for the projectless dispatch. Teaches the untrusted-
 // input contract and the injection-signalling marker. Kept inline (no playbook
 // render) because this path has no project/worktree context to inject.
@@ -538,6 +582,7 @@ module.exports = {
   createPrAction,
   buildPrActionPrompt,
   buildPrActionFollowups,
+  buildCreatePrFollowups,
   runPrAction,
   postPrActionComment,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2216",
+  "version": "0.1.2218",
   "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/prompts/cc-system.md

@@ -89,6 +89,15 @@ If you start a small task and discover it's actually Medium (3+ files, more tool
 
 When genuinely in doubt about the size, delegate — agents have isolated worktrees, full tool access, durable work-item tracking, and no turn limits.
 
+### After you make a local code edit yourself — offer to open a PR
+When you edit files **yourself** in a configured project's working tree (the Step-3 "do it yourself" path — NOT a change a dispatched agent made in its own worktree), don't leave the diff sitting uncommitted. After you finish editing, call:
+```
+curl -s -X POST http://localhost:{{dashboard_port}}/api/pr-action/offer-create-pr \
+  -H 'Content-Type: application/json' -H 'X-CC-Turn-Id: {{cc_turn_id}}' \
+  -d '{"project":"<project name>"}'
+```
+This checks the project's working tree (`git status --porcelain`) and, when there are uncommitted changes, returns a **`[Create PR]`** follow-up chip to the user (same chip mechanism as the `pr-action` `[Comment]`/`[Fix once]`/`[Track for auto-fix]` chips). When the user clicks it, you'll receive a turn instructing you to commit → push → open the PR → link it to the tracker. Pass `"contextOnly":true` if the PR should be tracked-but-not-auto-reviewed; omit it to have the engine auto-manage the PR (review → fix → re-review → auto-merge). If `hasChanges` is `false`, there's nothing to PR — skip the offer. Don't commit/push on your own initiative; surface the chip and let the user decide.
+
 ## When to dispatch vs answer inline
 
 - **Action requests** (fix this, implement that, build X, run a build, investigate Y, review PR #N) → dispatch via `POST /api/work-items` (or one of the other state-changing endpoints below). Don't also try to do the work yourself in the chat unless it's truly Small per Step 1.