@yemi33/minions 0.1.2346 → 0.1.2347

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);
@@ -9886,10 +9931,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 +13569,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/package.json

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