@yemi33/minions 0.1.1633 → 0.1.1634

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.1634 (2026-04-30)
+
+### Features
+- build-and-test CC action + docs playbook
+
 ## 0.1.1633 (2026-04-30)
 
 ### Features

package/dashboard.js

@@ -25,6 +25,9 @@ const ado = require('./engine/ado');
 const gh = require('./engine/github');
 const issues = require('./engine/issues');
 const watchesMod = require('./engine/watches');
+const routing = require('./engine/routing');
+const playbook = require('./engine/playbook');
+const dispatchMod = require('./engine/dispatch');
 const os = require('os');
 
 const { safeRead, safeReadDir, safeWrite, safeJson, safeJsonObj, safeJsonArr, safeUnlink, mutateJsonFileLocked, mutateWorkItems, getProjects: _getProjects, DONE_STATUSES, WI_STATUS, reopenWorkItem } = shared;
@@ -1238,6 +1241,49 @@ async function executeCCActions(actions) {
           results.push({ type: action.type, id, ok: true });
           break;
         }
+        case 'build-and-test': {
+          // Resolve PR by number, ID, or URL — same lookup that drives the link-pr / PR-row paths.
+          const allPrs = getPullRequests().filter(p => !p._ghost);
+          const pr = shared.findPrRecord(allPrs, action.pr) || null;
+          if (!pr) {
+            results.push({ type: 'build-and-test', error: `PR not found: ${action.pr}` });
+            break;
+          }
+          // Resolve project: explicit param wins, else PR's _project, else first configured project as last resort.
+          const projectName = action.project || pr._project || null;
+          const project = projectName
+            ? PROJECTS.find(p => p.name?.toLowerCase() === String(projectName).toLowerCase())
+            : null;
+          if (!project) {
+            results.push({ type: 'build-and-test', error: `Project not found for PR ${pr.id}: ${projectName || '(none)'}` });
+            break;
+          }
+          // Pick agent: explicit param wins; else routing for 'test' work type.
+          let agentId = action.agent && CONFIG.agents?.[action.agent] ? action.agent : null;
+          if (!agentId) {
+            agentId = routing.resolveAgent('test', CONFIG, { authorAgent: pr.agent });
+          }
+          if (!agentId) {
+            results.push({ type: 'build-and-test', error: 'No available agent for test routing' });
+            break;
+          }
+          const prNumber = shared.getPrNumber(pr);
+          const dispatchKey = `cc-bt-${project.name}-${pr.id}`;
+          const item = playbook.buildPrDispatch(agentId, CONFIG, project, pr, 'test', {
+            pr_id: pr.id, pr_number: prNumber, pr_title: pr.title || '', pr_branch: pr.branch || '',
+            pr_author: pr.agent || '', pr_url: pr.url || '',
+            project_path: project.localPath || '',
+            task: `Build & test ${pr.id}: ${pr.title || ''}`,
+          }, `Build & test ${pr.id}: ${pr.title || ''}`,
+          { dispatchKey, source: 'cc-build-and-test', pr, branch: pr.branch, project: { name: project.name, localPath: project.localPath } });
+          if (!item) {
+            results.push({ type: 'build-and-test', error: 'Failed to render build-and-test playbook' });
+            break;
+          }
+          const id = dispatchMod.addToDispatch(item);
+          results.push({ type: 'build-and-test', id, agent: agentId, pr: pr.id, ok: true });
+          break;
+        }
         case 'note': {
           shared.writeToInbox('command-center', shared.slugify(action.title || 'note'), `# ${action.title || 'Note'}\n\n${action.content || action.description || ''}`);
           results.push({ type: 'note', ok: true });

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-04-30T08:56:05.025Z"
+  "cachedAt": "2026-04-30T10:08:32.077Z"
 }

package/engine/playbook.js

@@ -278,6 +278,7 @@ const PLAYBOOK_REQUIRED_VARS = {
   'decompose':            ['item_id', 'item_description', 'project_path'],
   'verify':               ['task_description'],
   'test':                 ['item_name'],
+  'docs':                 ['item_id', 'item_name'],
   'work-item':            ['item_id', 'item_name'],
   'meeting-investigate':  ['meeting_title', 'agenda'],
   'meeting-debate':       ['meeting_title', 'agenda'],
@@ -630,7 +631,7 @@ function selectPlaybook(workType, item) {
   if (workType === WORK_TYPE.REVIEW && !item?._pr && !item?.pr_id) {
     return 'work-item';
   }
-  const typeSpecificPlaybooks = ['explore', 'review', 'test', 'plan-to-prd', 'plan', 'ask', 'verify', 'decompose', 'meeting-investigate', 'meeting-debate', 'meeting-conclude'];
+  const typeSpecificPlaybooks = ['explore', 'review', 'test', 'plan-to-prd', 'plan', 'ask', 'verify', 'decompose', 'docs', 'meeting-investigate', 'meeting-debate', 'meeting-conclude'];
   return typeSpecificPlaybooks.includes(workType) ? workType : 'work-item';
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1633",
+  "version": "0.1.1634",
   "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/docs.md

@@ -0,0 +1,113 @@
+# Docs Playbook
+
+> Agent: {{agent_name}} ({{agent_role}}) | Task: {{item_name}} | ID: {{item_id}}
+
+## Context
+
+Repo: {{repo_name}} | Org: {{ado_org}} | Project: {{ado_project}}
+Team root: {{team_root}}
+Project path: {{project_path}}
+
+## Mission
+
+Update, expand, or rewrite project documentation. Targets include READMEs, CLAUDE.md,
+files under `docs/`, JSDoc/TSDoc on exported APIs, and inline comments where they add
+real WHY value (not WHAT — the code already says what). Keep voice consistent with the
+project's existing docs.
+
+## Task
+
+**{{item_name}}**
+
+{{item_description}}
+
+{{additional_context}}
+
+{{references}}
+
+{{acceptance_criteria}}
+
+## Steps
+
+### 1. Read the doc(s) and the code they describe
+
+- Open the doc(s) being changed end-to-end before writing.
+- Read the source they describe — function signatures, exported symbols, config keys,
+  CLI flags, file paths. Don't trust the existing doc; trust the code.
+- For project-level docs (README, CLAUDE.md, /docs/*.md), skim adjacent docs so your
+  voice and structure match.
+
+### 2. Confirm doc reflects current code
+
+For every claim in the doc you're touching, verify it against current code:
+
+- Does the function still exist with that signature?
+- Are the file paths correct?
+- Are the listed flags / config keys still accepted?
+- Are removed features still being documented?
+- Are new features (visible in code) missing from the doc?
+
+If the doc describes vapor, delete the section. If real features are missing, add them.
+
+### 3. Write or update concisely
+
+- Match the project's existing voice — read 2-3 nearby docs to calibrate tone.
+- Prefer concrete examples over abstract description.
+- For code comments: follow the project's "Default to writing no comments" rule
+  (CLAUDE.md). Add comments only where they explain WHY a non-obvious choice was made,
+  never to restate WHAT the code does.
+- For project-level docs: the bar is "would a new contributor understand this?"
+- Keep tables, lists, and code blocks formatted consistently with surrounding docs.
+
+### 4. Verify
+
+- Re-read the changed doc end-to-end after editing — does it still flow?
+- If the project has doc-validation tests (lint, link-check, snippet-execution), run
+  them. Otherwise run `npm test` (or the project's documented test command) to make
+  sure nothing else broke.
+- For docs with embedded code samples, mentally execute each sample against current
+  code — stale samples are worse than missing ones.
+
+## Acceptance
+
+- Doc accurately reflects current code (no vapor, no missing features).
+- Voice and structure match the rest of the project's docs.
+- For inline code comments: follow project conventions; add comments only where they
+  explain WHY, never WHAT.
+- For project-level docs: a new contributor could read it and understand the topic.
+- Existing tests still pass; any doc-validation tests pass.
+
+## Git Workflow
+
+You are already running in a git worktree on branch `{{branch_name}}`. Do NOT create
+additional worktrees — the engine pre-created one for you. Do NOT remove the worktree —
+the engine handles cleanup automatically.
+
+Commit only the doc files (and any helper assets they reference). Do not bundle
+unrelated code changes into a docs PR.
+
+```bash
+git add <doc files>
+git commit -m "{{commit_message}}"
+git push -u origin {{branch_name}}
+```
+
+PR creation is MANDATORY for docs tasks — docs go through the same review flow as code.
+Use the appropriate repo-host tooling for PR creation. For Azure DevOps, prefer the
+`az` CLI first and use the ADO MCP only as a fallback.
+
+## Rules
+
+- Do NOT modify product code unless the task explicitly asks for it.
+- Do NOT add comments that restate what the code does.
+- Do NOT invent features that don't exist; verify against current code.
+- Read `notes.md` for all team rules before starting.
+
+## When to Stop
+
+Your task is complete once the doc accurately reflects current code, the PR is created
+with the changed doc files, and any doc-validation tests pass. Do not continue editing
+adjacent docs that weren't part of the task.
+
+## Team Decisions
+{{notes_content}}

package/prompts/cc-system.md

@@ -77,6 +77,8 @@ Core action types:
   workTypes: `explore` (research/report only, NO PR), `ask` (answer/report, NO PR), `implement` (new code, PR REQUIRED), `fix` (bug fix, PR REQUIRED), `review` (code review, NO PR), `test` (tests, PR if new), `verify` (merge/build/maintenance, NO PR)
   If the user wants a design/architecture artifact committed through a PR, dispatch `implement` or `docs` rather than `explore`.
   When the user names a specific agent ("assign this to lambert"), put exactly that one name in `agents` (e.g. `"agents": ["lambert"]`). A single-agent assignment is hard-pinned by the server — it will queue for that agent only and skip the routing table. Use multi-agent arrays only when the user names multiple agents or asks for fan-out.
+- **build-and-test**: pr, project (optional), agent (optional) — Run the build-and-test playbook against a PR. The agent will checkout the PR branch, run the project's build/test commands, and report results. Use when the user asks to "run tests on PR X" or "build PR X" or after a fix to verify nothing regressed.
+  Example: user says "run build and test on PR 1834" → `{"type":"build-and-test","pr":"1834"}`
 - **note**: title, content — save to inbox
 - **knowledge**: title, content, category (architecture/conventions/project-notes/build-reports/reviews) — create new KB entry or copy existing doc to KB
 - **pin-to-pinned**: title, content, level (critical/warning) — write to pinned.md, force-injected into ALL agent prompts (rarely needed)