@yemi33/minions 0.1.2346 → 0.1.2348

package/dashboard.js

@@ -6973,12 +6973,35 @@ const server = http.createServer(async (req, res) => {
       if (target.error) return jsonReply(res, 404, { error: target.error });
       const wiPath = target.wiPath;
 
+      // W-mrazefzz000358e3 — body.project reassigns which projects/<name>/
+      // work-items.json (or central) file owns this item. Resolve + validate
+      // it up front (mirrors resolveWorkItemsCreateTarget's create-path
+      // contract) so an unknown project name 400s cleanly instead of the
+      // historical silent no-op. `projectMove` stays null when body.project
+      // is omitted (no location change requested).
+      let projectMove = null;
+      if (body.project !== undefined) {
+        const projTarget = resolveProjectSourceTarget(body.project, PROJECTS);
+        if (projTarget.error) {
+          return jsonReply(res, 400, {
+            error: projTarget.error,
+            knownProjects: PROJECTS.map(p => p.name),
+          });
+        }
+        projectMove = { wiPath: projTarget.wiPath, projectName: projTarget.project ? projTarget.project.name : null };
+      }
+
       let result = null;
       let agentChanged = false;
+      // Set inside the source-file lock below when a project move is needed;
+      // inserted into the target file's own lock scope afterward so we never
+      // hold both files' locks at once.
+      let movedItem = null;
       mutateJsonFileLocked(wiPath, (items) => {
         if (!Array.isArray(items)) items = [];
-        const item = items.find(i => i.id === id);
-        if (!item) { result = { code: 404, body: { error: 'item not found' } }; return items; }
+        const idx = items.findIndex(i => i.id === id);
+        if (idx === -1) { result = { code: 404, body: { error: 'item not found' } }; return items; }
+        const item = items[idx];
         if (item.status === WI_STATUS.DISPATCHED) { result = { code: 400, body: { error: 'Cannot edit dispatched items' } }; return items; }
 
         if (title !== undefined) item.title = title;
@@ -7010,10 +7033,32 @@ const server = http.createServer(async (req, res) => {
           }
         }
         item.updatedAt = new Date().toISOString();
+
+        // W-mrazefzz000358e3 — actually MOVE the item between work-items.json
+        // files when the resolved target differs from where it lives today,
+        // rather than just stamping item.project in place. Only trip this
+        // when the resolved wiPath actually changes — re-assigning the same
+        // project the item already lives in is a no-op move.
+        if (projectMove && path.resolve(projectMove.wiPath) !== path.resolve(wiPath)) {
+          if (projectMove.projectName) item.project = projectMove.projectName;
+          else delete item.project;
+          movedItem = item;
+          items.splice(idx, 1);
+        }
+
         result = { code: 200, body: { ok: true, item } };
         return items;
       });
       if (!result) return jsonReply(res, 500, { error: 'unexpected state' });
+
+      if (movedItem) {
+        mutateJsonFileLocked(projectMove.wiPath, (targetItems) => {
+          if (!Array.isArray(targetItems)) targetItems = [];
+          targetItems.push(movedItem);
+          return targetItems;
+        });
+      }
+
       // Clear stale pending dispatch entries outside lock
       if (agentChanged) cleanDispatchEntries(d => d.meta?.item?.id === id);
       return jsonReply(res, result.code, result.body);
@@ -9800,8 +9845,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       const body = await readBody(req);
       const message = body && typeof body.message === 'string' ? body.message : '';
       if (!message.trim()) return jsonReply(res, 400, { error: 'message required' });
-      const watchId = body.watchId ? String(body.watchId) : '';
-      const label = watchId ? `watch-cc-triage:${watchId}` : 'watch-cc-triage';
+      // W-mrb1a3950003d9ea — flat, stable label (no per-watch-id interpolation).
+      // Every other _engine category (kb-sweep, consolidation, command-center, …)
+      // uses one flat label; a dynamic watchId suffix here used to mint a brand-new
+      // permanent metrics.json._engine key per watch firing (20+ confirmed live).
+      const label = 'watch-cc-triage';
 
       const model = CONFIG.engine?.ccModel || shared.ENGINE_DEFAULTS.ccModel;
       const maxTurns = CONFIG.engine?.ccMaxTurns || shared.ENGINE_DEFAULTS.ccMaxTurns;
@@ -9886,10 +9934,20 @@ What would you like to discuss or change? When you're happy, say "approve" and I
    * test enforces engine.js does not import cc-worker-pool).
    */
   function _invokeCcStream({ prompt, sessionId, liveState, toolUses, model, effort, maxTurns, engineConfig, systemPrompt = CC_STATIC_SYSTEM_PROMPT, tabId, images }) {
-    if (shared.resolveCcUseWorkerPool(engineConfig)) {
-      // The ACP worker pool is copilot-only (shared.resolveCcUseWorkerPool
-      // forces it OFF for non-copilot CC) and copilot has imageInput:false, so
-      // image turns never reach this branch — drop `images` here intentionally.
+    // W-mray463s001zcee2 — image-bearing turns bypass the worker pool.
+    // Copilot itself supports images fine (imageInput: true, `--attachment
+    // <path>` in engine/runtimes/copilot.js buildArgs), but the ACP worker-pool
+    // protocol (engine/cc-worker-pool.js session/prompt) only ever sends
+    // `[{ type: 'text', text: prompt }]` — it has no image/attachment
+    // content-block support today. That is a worker-pool PROTOCOL gap, not a
+    // Copilot capability gap (the old comment here claiming "copilot has
+    // imageInput:false" was factually wrong). Until the pool's ACP session
+    // protocol is extended to carry attachments, route image turns around the
+    // pool for THIS TURN ONLY: cold-spawn a one-off CLI process via the
+    // already-working --attachment path below, while image-less turns keep
+    // using the fast warm pool.
+    const hasImages = Array.isArray(images) && images.length > 0;
+    if (!hasImages && shared.resolveCcUseWorkerPool(engineConfig)) {
       return _invokeCcStreamViaPool({ prompt, liveState, toolUses, model, effort, engineConfig, systemPrompt, tabId });
     }
     const { callLLMStreaming } = require('./engine/llm');
@@ -13514,7 +13572,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
     // Work items
     { method: 'POST', path: '/api/work-items', desc: 'Create a new work item', params: 'title, type?, description?, priority?, project?, agent?, agents?, scope?, references?, acceptanceCriteria?, skipPr?, oneShot?, meta?, meta.pr_followup?, meta.workdir?, X-Minions-Agent?, X-Minions-Origin-Wi?', handler: handleWorkItemsCreate },
-    { method: 'POST', path: '/api/work-items/update', desc: 'Edit a pending/failed work item', params: 'id, source?, title?, description?, type?, priority?, agent?, references?, acceptanceCriteria?, depends_on?, workdir?, meta?', handler: handleWorkItemsUpdate },
+    { method: 'POST', path: '/api/work-items/update', desc: 'Edit a pending/failed work item', params: 'id, source?, title?, description?, type?, priority?, agent?, project?, references?, acceptanceCriteria?, depends_on?, workdir?, meta?', handler: handleWorkItemsUpdate },
     { method: 'POST', path: '/api/work-items/retry', desc: 'Reset a failed/dispatched item to pending', params: 'id, source?', handler: handleWorkItemsRetry },
     { method: 'POST', path: '/api/work-items/delete', desc: 'Remove a work item, kill agent, clear dispatch', params: 'id, source?', handler: handleWorkItemsDelete },
     { method: 'POST', path: '/api/work-items/cancel', desc: 'Cancel a work item, kill agent, clear dispatch', params: 'id, source?, reason?', handler: handleWorkItemsCancel },

package/docs/command-center.md

@@ -65,9 +65,11 @@ Any violation rejects the **whole turn** with a typed error envelope (`code: 'in
 | Runtime | `imageInput` | Behavior |
 |---------|--------------|----------|
 | claude  | `true`  | Images delivered as an Anthropic Messages `content[]` envelope of base64 blocks over stream-json (`claude.buildPrompt` + `--input-format stream-json` in `claude.buildArgs`). |
-| copilot | `true` | Images materialized to tmp files and passed as `--attachment <path>` (W-mqv7324u0021db5d). **Exception:** when the opt-in Copilot worker pool is active (`engine.ccUseWorkerPool: true`), images are silently dropped — the pool's ACP `stream()` does not forward images; a note in `_invokeCcStream` marks this intentional. |
+| copilot | `true` | Images materialized to tmp files and passed as `--attachment <path>` (W-mqv7324u0021db5d). |
 | codex   | `false` | Degraded — same typed `model-unavailable` envelope. |
 
+**Worker-pool interaction (W-mray463s001zcee2).** The opt-in Copilot ACP worker pool (`engine.ccUseWorkerPool: true`, default ON for Copilot CC) is a **separate protocol path** from the table above — `engine/cc-worker-pool.js`'s `session/prompt` call only ever sends a single text content block (`[{ type: 'text', text: prompt }]`) and has no image/attachment content-block support today. This used to mean image turns were silently dropped whenever the pool was active, with a comment incorrectly blaming a Copilot capability gap (`imageInput:false`) that doesn't exist — Copilot's `imageInput` is `true` and fully supports images on the direct spawn path. The fix: `_invokeCcStream` (dashboard.js) now checks for a non-empty `images` array **before** routing through `resolveCcUseWorkerPool` — image-bearing turns bypass the warm pool for that turn only and cold-spawn a one-off CLI process via the working `--attachment` path (same as the non-pooled path always used), while image-less turns keep using the fast warm pool. If `engine/cc-worker-pool.js`'s ACP session protocol is later extended to carry attachments (Option A), this per-turn bypass in `_invokeCcStream` should be revisited/removed.
+
 `_resolveImageOpts` (in `engine/llm.js`) is pure and unit-tested: it forwards the `images` list only when `runtime.capabilities.imageInput` is truthy, otherwise returns the typed error so CC/doc-chat surface the envelope instead of a silently-text-only reply. `_spawnProcess` re-applies the same gate (`if (!caps.imageInput) adapterOpts.images = undefined`) as defense in depth. Image **filenames** are run through the untrusted-input fence (`buildSource('cc-image-filename', …)`) before they reach prompt text, since they are user-supplied.
 
 **No new `engine.*` flag.** The limits above are module-level constants in `dashboard.js` (`CC_IMAGE_MAX_COUNT`, `CC_IMAGE_MAX_DECODED_BYTES`, `CC_IMAGE_MIME_ALLOWLIST`), not config keys; `engine/shared.js` `ENGINE_DEFAULTS` was not touched. Per CLAUDE.md Best Practice #9 (Settings parity), no Settings toggle is added because no new `engine.*` flag was introduced. Runtime selection that determines whether images are accepted is the existing `engine.ccCli` / `ccModel` override, which already has a Settings control.

package/engine/metrics-store.js

@@ -172,6 +172,8 @@ function readMetrics() {
   try { db = getDb(); }
   catch { return _readJsonObjectFallback(); }
 
+  migrateWatchCcTriageKeysOnce();
+
   _resyncIfJsonDiverged(db);
 
   const rows = _readAllRows(db);
@@ -285,9 +287,73 @@ function _resetMetricsTableForTest() {
   _lastMirrorHash = null;
 }
 
+// W-mrb1a3950003d9ea — one-time collapse of legacy `watch-cc-triage:<watchId>`
+// per-watch _engine keys (minted before dashboard.js's handleCommandCenterTriage
+// stopped interpolating watchId into the trackEngineUsage label) into a single
+// flat `watch-cc-triage` bucket, matching every other _engine category. Sums
+// calls/cost/tokens/duration/errorsByCode across all matching keys, then deletes
+// the per-id keys. Idempotent — a no-op (no SQL/JSON write) once no key matches
+// /^watch-cc-triage:/, so it's safe to call unconditionally on every process
+// startup via migrateWatchCcTriageKeysOnce().
+const WATCH_CC_TRIAGE_LEGACY_KEY_RE = /^watch-cc-triage:/;
+const WATCH_CC_TRIAGE_FLAT_KEY = 'watch-cc-triage';
+
+function migrateWatchCcTriageKeys() {
+  return applyMetricsMutation((metrics) => {
+    const engineMetrics = metrics._engine;
+    if (!engineMetrics || typeof engineMetrics !== 'object') return metrics;
+    const staleKeys = Object.keys(engineMetrics).filter((k) => WATCH_CC_TRIAGE_LEGACY_KEY_RE.test(k));
+    if (staleKeys.length === 0) return metrics;
+
+    if (!engineMetrics[WATCH_CC_TRIAGE_FLAT_KEY]) {
+      engineMetrics[WATCH_CC_TRIAGE_FLAT_KEY] = { calls: 0, costUsd: 0, inputTokens: 0, outputTokens: 0, cacheRead: 0, cacheCreation: 0 };
+    }
+    const flat = engineMetrics[WATCH_CC_TRIAGE_FLAT_KEY];
+    for (const key of staleKeys) {
+      const cat = engineMetrics[key] || {};
+      flat.calls = (flat.calls || 0) + (cat.calls || 0);
+      flat.costUsd = (flat.costUsd || 0) + (cat.costUsd || 0);
+      flat.inputTokens = (flat.inputTokens || 0) + (cat.inputTokens || 0);
+      flat.outputTokens = (flat.outputTokens || 0) + (cat.outputTokens || 0);
+      flat.cacheRead = (flat.cacheRead || 0) + (cat.cacheRead || 0);
+      flat.cacheCreation = (flat.cacheCreation || 0) + (cat.cacheCreation || 0);
+      if (cat.totalDurationMs) flat.totalDurationMs = (flat.totalDurationMs || 0) + cat.totalDurationMs;
+      if (cat.timedCalls) flat.timedCalls = (flat.timedCalls || 0) + cat.timedCalls;
+      if (cat.errorsByCode) {
+        if (!flat.errorsByCode) flat.errorsByCode = {};
+        for (const [code, count] of Object.entries(cat.errorsByCode)) {
+          flat.errorsByCode[code] = (flat.errorsByCode[code] || 0) + count;
+        }
+      }
+      delete engineMetrics[key];
+    }
+    return metrics;
+  });
+}
+
+let _watchCcTriageMigratedThisProcess = false;
+
+// Startup-safe wrapper: runs migrateWatchCcTriageKeys() at most once per
+// process (subsequent calls, e.g. on every readMetrics(), are a cheap
+// no-op flag check). Failures (e.g. SQLite unavailable) are swallowed and
+// retried on the next process start rather than surfaced to callers.
+function migrateWatchCcTriageKeysOnce() {
+  if (_watchCcTriageMigratedThisProcess) return;
+  _watchCcTriageMigratedThisProcess = true;
+  try { migrateWatchCcTriageKeys(); }
+  catch { /* best-effort — next process start retries */ }
+}
+
+function _resetWatchCcTriageMigrationFlagForTest() {
+  _watchCcTriageMigratedThisProcess = false;
+}
+
 module.exports = {
   readMetrics,
   applyMetricsMutation,
   _mirrorJsonFromSql,
   _resetMetricsTableForTest,
+  migrateWatchCcTriageKeys,
+  migrateWatchCcTriageKeysOnce,
+  _resetWatchCcTriageMigrationFlagForTest,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2346",
+  "version": "0.1.2348",
   "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"