@yemi33/minions 0.1.1952 → 0.1.1954

package/engine/cli.js

@@ -772,6 +772,22 @@ const commands = {
       }
     })();
 
+    // W-mp7gox8w000n8936 — Boot reconcile for kb-sweep state: clear stale
+    // `in-flight`/`starting` records left over from a crashed runner (or a
+    // legacy pre-pid runner). Without this, the record sits there clogging
+    // /api/knowledge/sweep/status until someone POSTs a new sweep. Idempotent.
+    (function startupReconcileKbSweep() {
+      try {
+        const { reconcileSweepStateOnBoot } = require('./kb-sweep');
+        const stats = reconcileSweepStateOnBoot();
+        if (stats.released > 0) {
+          console.log(`  KB-sweep boot reconcile: released stale ${stats.prevStatus} record (pid=${stats.prevPid}, reason=${stats.reason})`);
+        }
+      } catch (err) {
+        e.log('warn', `KB-sweep boot reconcile failed: ${err.message}`);
+      }
+    })();
+
     // Initial tick
     e.tick();
 

package/engine/kb-sweep.js

@@ -339,6 +339,91 @@ function readSweepLiveness(opts = {}) {
   };
 }
 
+/**
+ * One-shot boot-time reconciliation for `engine/kb-sweep-state.json`.
+ *
+ * Mirrors the worktree-pool / keep-process boot reconcilers in `engine/cli.js`:
+ * after an engine restart we may inherit a stale `in-flight`/`starting` record
+ * whose runner has long since died (or — for legacy state files — never
+ * recorded a pid). Without proactive cleanup the record sits there clogging
+ * `/api/knowledge/sweep/status` until someone POSTs a new sweep (which the
+ * dashboard's stale-guard would then auto-release).
+ *
+ * Behavior:
+ *   - Absent state file → no-op.
+ *   - Terminal status (completed/failed) → no-op.
+ *   - `starting` within 15s boot-grace → no-op (matches readSweepLiveness).
+ *   - `in-flight` / stale `starting` with a live pid → no-op (running sweep).
+ *   - Otherwise rewrite to `status: 'failed'` preserving the original pid for
+ *     forensics. The original record fields are kept; `reconciliationReason`
+ *     records why we released it.
+ *
+ * CAS guard: re-reads state immediately before the write and aborts if any of
+ * status/startedAt/pid/sweepToken changed since the snapshot — protects against
+ * a concurrent dashboard POST or runner that wrote a fresh record between our
+ * decision and our write.
+ *
+ * @param {object} [opts]
+ * @param {number} [opts.now=Date.now()]                injectable clock (tests)
+ * @param {(pid:number)=>boolean} [opts.isPidAlive]    injectable (tests)
+ * @returns {{ scanned:number, released:number, reason?:string,
+ *             prevStatus?:string, prevPid?:number }}
+ */
+function reconcileSweepStateOnBoot(opts = {}) {
+  const now = Number(opts.now) || Date.now();
+  const isPidAlive = typeof opts.isPidAlive === 'function'
+    ? opts.isPidAlive
+    : (pid) => { try { process.kill(pid, 0); return true; } catch { return false; } };
+  const state = safeJson(KB_SWEEP_STATE_PATH);
+  if (!state) return { scanned: 0, released: 0 };
+  if (state.status !== 'in-flight' && state.status !== 'starting') {
+    return { scanned: 1, released: 0, reason: `terminal-status-${state.status}` };
+  }
+  if (state.status === 'starting') {
+    const STARTING_GRACE_MS = 15000;
+    const age = state.startedAt ? now - Number(state.startedAt) : Infinity;
+    if (age <= STARTING_GRACE_MS) {
+      return { scanned: 1, released: 0, reason: 'within-boot-grace' };
+    }
+  }
+  const pid = Number(state.pid) || 0;
+  const alive = pid > 0 ? !!isPidAlive(pid) : false;
+  if (alive) {
+    return { scanned: 1, released: 0, reason: 'pid-still-alive', prevPid: pid };
+  }
+
+  const reason = pid > 0 ? 'pid-dead-on-startup-check' : 'no-pid-recorded-on-startup-check';
+
+  // CAS guard: re-read right before the write so we don't clobber a fresh
+  // `starting`/`in-flight` record that a concurrent dashboard POST or runner
+  // wrote between our decision and our write.
+  const current = safeJson(KB_SWEEP_STATE_PATH);
+  if (!current
+      || current.status !== state.status
+      || Number(current.startedAt || 0) !== Number(state.startedAt || 0)
+      || Number(current.pid || 0) !== pid
+      || (current.sweepToken || null) !== (state.sweepToken || null)) {
+    return { scanned: 1, released: 0, reason: 'state-changed-before-reconcile' };
+  }
+
+  const failedState = {
+    ...state,
+    status: 'failed',
+    completedAt: now,
+    completedAtIso: new Date(now).toISOString(),
+    error: `sweep abandoned: ${reason}`,
+    reconciliationReason: reason,
+  };
+  // Direct safeWrite (NOT _writeSweepState) so the original pid is preserved
+  // for forensics — _writeSweepState would overwrite it with this process's
+  // pid, destroying the diagnostic value of the record.
+  try { safeWrite(KB_SWEEP_STATE_PATH, JSON.stringify(failedState)); } catch { /* ignore */ }
+  return {
+    scanned: 1, released: 1, reason,
+    prevStatus: state.status, prevPid: pid,
+  };
+}
+
 /**
  * Run the full sweep. Returns a rich summary.
  *
@@ -480,6 +565,7 @@ module.exports = {
   runKbSweep,
   staleGuardMs,
   readSweepLiveness,
+  reconcileSweepStateOnBoot,
   KB_SWEEP_STATE_PATH,
   KB_SWEEP_LOG_PATH,
   KB_SWEEP_RUNNER_PATH,

package/engine/watches.js

@@ -9,18 +9,62 @@
  *
  * Target-type behavior is data-driven via a registry — see TARGET_TYPES below.
  * Each registered target type provides:
- *   - label:        human-friendly name shown in dashboard pickers
- *   - conditions:   array of condition keys this target type accepts
- *   - fetchEntity:  (target, state) => entity-or-null lookup
- *   - captureState: (entity) => snapshot for change-detection diffing
- *   - evaluate:     (condition, entity, prevState, target) => { triggered, message }
+ *   - label:              human-friendly name shown in dashboard pickers
+ *   - conditions:         array of condition keys this target type accepts
+ *   - absoluteConditions: (optional) array of condition keys that should
+ *                         fire-once when stopAfter=0 (compound state assertions
+ *                         like "merged" / "completed"). Normalized into a Set
+ *                         on the spec at registration time.
+ *   - fetchEntity:        (target, state) => entity-or-null lookup
+ *   - captureState:       (entity, prevState) => snapshot for change-detection
+ *   - evaluate:           (condition, entity, prevState, target) =>
+ *                         { triggered, message }
+ *   - contextVars:        (optional) (entity, prevState, newState) =>
+ *                         object of extra template vars merged into the
+ *                         action ctx after buildTriggerContext. Used by
+ *                         plugins to surface fields that aren't auto-promoted
+ *                         from newState (e.g. {{prevExtracted}}) or to alias
+ *                         scalars under nicer names.
  *
  * Built-in types: pr, work-item, meeting, plan, schedule, pipeline, dispatch,
  * agent. Additional types can be added at runtime via registerTargetType().
  *
+ * Canonical plugin example: `watches.d/http.js` (W-mp7i22mu00191b07) — a
+ * generic HTTP poller that demonstrates the full plugin contract including
+ * `contextVars` (exposing `{{httpStatus}}`, `{{extracted}}`, `{{prevExtracted}}`,
+ * etc. to action templates) and a background-fetch cache (because the engine
+ * tick path is synchronous; plugins that need async I/O maintain their own
+ * cache and return cached entities from the synchronous fetchEntity).
+ *
+ * ── Plugin folder (`watches.d/`) — W-mp7hg58e000b5212 ────────────────────────
+ *
+ * At engine boot, every `*.js` file in `<MINIONS_DIR>/watches.d/` is loaded
+ * and its exports are passed to registerTargetType(). This lets users add
+ * new watch target types without editing engine source.
+ *
+ * Each plugin file exports either:
+ *
+ *   module.exports = {
+ *     name: 'gh-workflow-run',
+ *     spec: { label, conditions, absoluteConditions?, fetchEntity, captureState, evaluate, ... },
+ *   };
+ *
+ * or an array of those objects for multi-target plugins.
+ *
+ * Resolution: `path.join(MINIONS_DIR, 'watches.d')` so it works in both dev
+ * (D:/squad) and installed (~/.minions) layouts. A missing folder is a silent
+ * no-op (not an error). Each file is required inside its own try/catch — one
+ * bad plugin must not break boot or block other plugins. Successful loads
+ * log at INFO; registration failures log at WARN with the file path.
+ *
+ * Security: plugins are user-trusted JS (same trust level as `playbooks/` and
+ * `pipelines/`); no sandboxing. Hot-reload is not supported — restart the
+ * engine to pick up new plugin files (matches how playbooks already work).
+ *
  * State stored in engine/watches.json — concurrency-safe via mutateJsonFileLocked.
  */
 
+const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
 const { safeJsonArr, mutateJsonFileLocked, ts, uid, log, writeToInbox,
@@ -59,12 +103,23 @@ const TARGET_TYPES = {};
 /**
  * Register a watch target type.
  * @param {string} type - Unique key (e.g. 'pr', 'meeting', 'custom-thing')
- * @param {object} spec - { label, conditions, fetchEntity, captureState, evaluate }
- *   - label:        string shown in dashboard pickers
- *   - conditions:   array of condition strings the type accepts
- *   - fetchEntity:  (target, state) => entity-or-null
- *   - captureState: (entity) => snapshot object
- *   - evaluate:     (condition, entity, prevState, target) => { triggered, message }
+ * @param {object} spec - { label, conditions, absoluteConditions?, fetchEntity, captureState, evaluate }
+ *   - label:              string shown in dashboard pickers
+ *   - conditions:         array of condition strings the type accepts
+ *   - absoluteConditions: (optional) array of condition keys that should fire
+ *                         once and auto-expire when stopAfter=0. Normalized
+ *                         into a Set on the spec; defaults to an empty Set.
+ *                         Each entry MUST also appear in `conditions`.
+ *   - fetchEntity:        (target, state) => entity-or-null
+ *   - captureState:       (entity, prevState) => snapshot object
+ *   - evaluate:           (condition, entity, prevState, target) =>
+ *                         { triggered, message }
+ *   - contextVars:        (optional) (entity, prevState, newState) =>
+ *                         object whose keys are merged into the action ctx
+ *                         after buildTriggerContext. Use to expose plugin-
+ *                         specific template vars that aren't auto-promoted
+ *                         scalars from newState (e.g. previousState scalars
+ *                         like {{prevExtracted}}). Errors are logged + swallowed.
  */
 function registerTargetType(type, spec) {
   if (!type || typeof type !== 'string') throw new Error('registerTargetType: type must be a non-empty string');
@@ -75,7 +130,26 @@ function registerTargetType(type, spec) {
   if (!Array.isArray(spec.conditions) || spec.conditions.length === 0) {
     throw new Error(`registerTargetType(${type}): spec.conditions must be a non-empty array`);
   }
-  TARGET_TYPES[type] = spec;
+  // W-mp7hg58e000b5212 — normalize absoluteConditions into a Set for fast
+  // .has() lookup at evaluate-time. Accepts an array (declarative spec form)
+  // or pre-built Set; defaults to empty when omitted. Entries must be a
+  // subset of `conditions` so a typo here doesn't silently no-op.
+  let absoluteSet;
+  if (spec.absoluteConditions === undefined || spec.absoluteConditions === null) {
+    absoluteSet = new Set();
+  } else if (spec.absoluteConditions instanceof Set) {
+    absoluteSet = new Set(spec.absoluteConditions);
+  } else if (Array.isArray(spec.absoluteConditions)) {
+    absoluteSet = new Set(spec.absoluteConditions);
+  } else {
+    throw new Error(`registerTargetType(${type}): spec.absoluteConditions must be an array or Set`);
+  }
+  for (const c of absoluteSet) {
+    if (!spec.conditions.includes(c)) {
+      throw new Error(`registerTargetType(${type}): absoluteConditions entry '${c}' is not in conditions[]`);
+    }
+  }
+  TARGET_TYPES[type] = { ...spec, absoluteConditions: absoluteSet };
 }
 
 /** Returns the registered spec for a target type, or null. */
@@ -420,7 +494,14 @@ function checkWatches(config, state) {
           // Expire when stopAfter > 0 and trigger count reaches the limit.
           // Absolute conditions (merged, build-pass, etc.) auto-expire on first trigger
           // when stopAfter=0 — fire-once semantics. Change-based conditions run forever.
-          const isAbsolute = WATCH_ABSOLUTE_CONDITIONS.has(watch.condition);
+          // W-mp7hg58e000b5212 — resolves through the per-target-type
+          // absoluteConditions Set (declared in each spec); falls back to the
+          // legacy WATCH_ABSOLUTE_CONDITIONS union only when the watch's
+          // targetType has been unregistered between create and check (defensive).
+          const _absSpec = TARGET_TYPES[watch.targetType];
+          const isAbsolute = _absSpec
+            ? _absSpec.absoluteConditions.has(watch.condition)
+            : WATCH_ABSOLUTE_CONDITIONS.has(watch.condition);
           if ((watch.stopAfter > 0 && watch.triggerCount >= watch.stopAfter) ||
               (watch.stopAfter === 0 && isAbsolute)) {
             watch.status = WATCH_STATUS.EXPIRED;
@@ -485,6 +566,18 @@ async function _runActionTask(task) {
     entity: task.entity,
     message: task.message,
   });
+  // W-mp7i22mu00191b07 — let the registered target type contribute extra
+  // template vars (e.g. http plugin exposes {{httpStatus}}, {{prevExtracted}}).
+  // Failures are swallowed so a misbehaving plugin can't poison action dispatch.
+  const tt = TARGET_TYPES[task.snapshot.targetType];
+  if (tt && typeof tt.contextVars === 'function') {
+    try {
+      const extras = tt.contextVars(task.entity, task.previousState, task.newState) || {};
+      if (extras && typeof extras === 'object') Object.assign(ctx, extras);
+    } catch (err) {
+      log('warn', `${task.snapshot.targetType} contextVars failed: ${err.message}`);
+    }
+  }
   const result = await watchActions.runWatchAction(task.snapshot, ctx);
   const isChain = Array.isArray(task.snapshot.action);
   const actionLabel = isChain
@@ -591,6 +684,12 @@ registerTargetType(WATCH_TARGET_TYPE.PR, {
     WATCH_CONDITION.READY_FOR_MERGE, WATCH_CONDITION.BEHIND_MASTER,
     WATCH_CONDITION.DRAFT_FLIPPED,
   ],
+  // W-mp7hg58e000b5212 — per-target absolute (fire-once when stopAfter=0).
+  // Mirrors what shared.WATCH_ABSOLUTE_CONDITIONS used to centralize for PR.
+  absoluteConditions: [
+    WATCH_CONDITION.MERGED, WATCH_CONDITION.BUILD_FAIL, WATCH_CONDITION.BUILD_PASS,
+    WATCH_CONDITION.READY_FOR_MERGE,
+  ],
   fetchEntity: (target, state) => findPrByTarget(state.pullRequests, target),
   captureState: (pr) => ({
     status: pr.status, buildStatus: pr.buildStatus, reviewStatus: pr.reviewStatus,
@@ -708,6 +807,11 @@ registerTargetType(WATCH_TARGET_TYPE.WORK_ITEM, {
     WATCH_CONDITION.STALLED, WATCH_CONDITION.RETRY_LIMIT_REACHED,
     WATCH_CONDITION.DEPENDENCY_MET,
   ],
+  // W-mp7hg58e000b5212 — per-target absolute (fire-once when stopAfter=0).
+  absoluteConditions: [
+    WATCH_CONDITION.COMPLETED, WATCH_CONDITION.FAILED,
+    WATCH_CONDITION.RETRY_LIMIT_REACHED,
+  ],
   fetchEntity: (target, state) => (state.workItems || []).find(w => w.id === target) || null,
   // P-w2c8d1e7 — Phase 1.2: surface retry count, pending-reason, and branch
   // for upcoming stalled / branch-aware predicates. `retries` aliases the
@@ -797,6 +901,7 @@ registerTargetType(WATCH_TARGET_TYPE.MEETING, {
   label: 'Meeting',
   description: 'Watch a meeting for conclusion or status changes',
   conditions: [WATCH_CONDITION.CONCLUDED, WATCH_CONDITION.STATUS_CHANGE, WATCH_CONDITION.ANY],
+  absoluteConditions: [WATCH_CONDITION.CONCLUDED],
   fetchEntity: (target, state) => (state.meetings || []).find(m => m && m.id === target) || null,
   captureState: (m) => ({ status: m.status }),
   evaluate: (condition, m, prevState, target) => {
@@ -866,6 +971,11 @@ registerTargetType(WATCH_TARGET_TYPE.PLAN, {
     // from the PRD's missing_features array.
     WATCH_CONDITION.ALL_ITEMS_DONE, WATCH_CONDITION.ITEM_FAILED_N_TIMES,
   ],
+  // W-mp7hg58e000b5212 — per-target absolute (fire-once when stopAfter=0).
+  absoluteConditions: [
+    WATCH_CONDITION.APPROVED, WATCH_CONDITION.REJECTED, WATCH_CONDITION.COMPLETED,
+    WATCH_CONDITION.ALL_ITEMS_DONE, WATCH_CONDITION.ITEM_FAILED_N_TIMES,
+  ],
   fetchEntity: _findPlan,
   // P-w2c8d1e7 — Phase 1.2: surface item progress derived from the PRD's
   // missing_features array so plan-level predicates (e.g. all-items-done)
@@ -941,6 +1051,9 @@ registerTargetType(WATCH_TARGET_TYPE.SCHEDULE, {
     WATCH_CONDITION.RAN, WATCH_CONDITION.ENABLED, WATCH_CONDITION.DISABLED,
     WATCH_CONDITION.STATUS_CHANGE, WATCH_CONDITION.ANY,
   ],
+  // W-mp7hg58e000b5212 — schedule has no absolute conditions today; all of
+  // its keywords are change-based (RAN/ENABLED/DISABLED detect transitions).
+  absoluteConditions: [],
   fetchEntity: _findSchedule,
   // P-w2c8d1e7 — Phase 1.2: surface next_run as null. Cron parsing in
   // engine/scheduler.js exposes parseCronExpr/.matches() but not a
@@ -1024,6 +1137,8 @@ registerTargetType(WATCH_TARGET_TYPE.PIPELINE, {
     // counter computed inside captureState.
     WATCH_CONDITION.STAGE_ADVANCED, WATCH_CONDITION.STUCK_IN_STAGE,
   ],
+  // W-mp7hg58e000b5212 — per-target absolute (fire-once when stopAfter=0).
+  absoluteConditions: [WATCH_CONDITION.COMPLETED, WATCH_CONDITION.FAILED],
   fetchEntity: _findPipelineLatestRun,
   // P-w2c8d1e7 — Phase 1.2: surface current_stage_id (first non-terminal
   // stage in declaration order) for stage-targeted predicates.
@@ -1116,6 +1231,8 @@ registerTargetType(WATCH_TARGET_TYPE.DISPATCH, {
     WATCH_CONDITION.COMPLETED, WATCH_CONDITION.FAILED,
     WATCH_CONDITION.STATUS_CHANGE, WATCH_CONDITION.ANY,
   ],
+  // W-mp7hg58e000b5212 — per-target absolute (fire-once when stopAfter=0).
+  absoluteConditions: [WATCH_CONDITION.COMPLETED, WATCH_CONDITION.FAILED],
   fetchEntity: _findDispatchEntry,
   captureState: (e) => ({ status: e.status || e._list || null, list: e._list || null }),
   evaluate: (condition, e, prevState, target) => {
@@ -1157,6 +1274,9 @@ registerTargetType(WATCH_TARGET_TYPE.AGENT, {
   conditions: [
     WATCH_CONDITION.ACTIVITY_CHANGE, WATCH_CONDITION.STATUS_CHANGE, WATCH_CONDITION.ANY,
   ],
+  // W-mp7hg58e000b5212 — agent has no absolute conditions today; all of its
+  // keywords are change-based.
+  absoluteConditions: [],
   fetchEntity: _findAgent,
   // P-w2c8d1e7 — Phase 1.2: surface currentDispatchId so predicates can
   // distinguish "agent now working on a different dispatch" from a plain
@@ -1190,6 +1310,49 @@ registerTargetType(WATCH_TARGET_TYPE.AGENT, {
   },
 });
 
+// ── Plugin folder discovery (W-mp7hg58e000b5212) ─────────────────────────────
+// Auto-load `<MINIONS_DIR>/watches.d/*.js` at module load time, AFTER the 8
+// built-in registerTargetType() calls so plugins can override built-ins by
+// re-using their key (last-write-wins). Per the README block at the top of
+// this file: missing folder is silent, per-file try/catch isolates failures,
+// and INFO/WARN logs trace what loaded.
+function _loadPluginTargetTypes() {
+  const dir = path.join(shared.MINIONS_DIR, 'watches.d');
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return; // silent no-op
+    log('warn', `watches.d/ readdir failed: ${err.message}`);
+    return;
+  }
+  for (const fname of entries.sort()) {
+    if (!fname.endsWith('.js')) continue;
+    const fp = path.join(dir, fname);
+    try {
+      // Bust cache so re-loads (tests, future hot-reload) pick up file edits.
+      try { delete require.cache[require.resolve(fp)]; } catch {}
+      const mod = require(fp);
+      const list = Array.isArray(mod) ? mod : [mod];
+      for (const entry of list) {
+        if (!entry || !entry.name || !entry.spec) {
+          log('warn', `watches.d/${fname}: export missing { name, spec } — skipping entry`);
+          continue;
+        }
+        try {
+          registerTargetType(entry.name, entry.spec);
+          log('info', `Loaded watch target type '${entry.name}' from watches.d/${fname}`);
+        } catch (regErr) {
+          log('warn', `watches.d/${fname}: registerTargetType('${entry.name}') failed: ${regErr.message}`);
+        }
+      }
+    } catch (err) {
+      log('warn', `watches.d/${fname}: load failed: ${err.message}`);
+    }
+  }
+}
+_loadPluginTargetTypes();
+
 module.exports = {
   DEFAULT_WATCH_INTERVAL,
   getWatches,
@@ -1214,4 +1377,5 @@ module.exports = {
   _watchesPath,   // exported for testing — dynamic, respects MINIONS_TEST_DIR
   _runActionTask, // exported for testing — invoked by checkWatches per fired action
   _TARGET_TYPES: TARGET_TYPES, // exported for testing — direct registry access
+  _loadPluginTargetTypes, // exported for testing — re-scans watches.d/
 };

package/engine.js

@@ -910,6 +910,19 @@ async function spawnAgent(dispatchItem, config) {
   };
   _phaseT.afterPrompt = Date.now();
 
+  if (branchName && READ_ONLY_ROOT_TASK_TYPES.has(type) && !isPipelineBranchName(branchName)) {
+    // W-mp7havqf0007ce6b: read-only types (meeting/ask/explore/plan/plan-to-prd)
+    // short-circuit BEFORE the worktree-creation block. resolveSpawnPaths returns
+    // worktreeRootDir=null for read-only types, and path.resolve(null, ...) throws
+    // ("paths[0] must be of type string. Received null"). Pipeline branches are
+    // exempt — they always need a worktree (the worktree IS the pipeline workspace),
+    // and the recompute at lines ~806-824 ensures worktreeRootDir is non-null
+    // before the worktree-creation block runs for them.
+    log('info', `${type}: read-only task with branch ${branchName} — skipping worktree, running in cwd ${cwd}`);
+    branchName = null;
+    worktreePath = null;
+  }
+
   if (branchName) {
     updateAgentStatus(id, AGENT_STATUS.WORKTREE_SETUP, `Setting up worktree for branch ${branchName}`);
     const wtDirName = shared.buildWorktreeDirName({
@@ -949,12 +962,6 @@ async function spawnAgent(dispatchItem, config) {
       _phaseT.reuseSyncStart = Date.now();
       await syncReusedWorktree(rootDir, existingWt, branchName, _gitOpts);
       _phaseT.reuseSyncEnd = Date.now();
-    } else if (READ_ONLY_ROOT_TASK_TYPES.has(type) && !isPipelineBranchName(branchName)) {
-      // Read-only tasks — no worktree needed, run in cwd from resolveSpawnPaths
-      // (project.localPath or MINIONS_DIR). W-mp73x32w000l143d.
-      log('info', `${type}: read-only task, no worktree needed — running in cwd ${cwd}`);
-      branchName = null;
-      worktreePath = null;
     } else {
       _phaseT.createWorktreeStart = Date.now();
 

package/package.json

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