@yemi33/minions 0.1.1703 → 0.1.1705

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.1705 (2026-05-04)
+
+### Features
+- prevent one-shot PR contamination
+
 ## 0.1.1703 (2026-05-04)
 
 ### Features

package/dashboard/js/render-schedules.js

@@ -302,6 +302,7 @@ function renderSchedules(schedules) {
         '<td>' + enabledBadge + '</td>' +
         '<td><span class="pr-date">' + escHtml(lastRun) + '</span></td>' +
         '<td style="white-space:nowrap">' +
+          '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--green);border-color:var(--green);margin-right:4px" onclick="event.stopPropagation();runScheduleNow(\'' + escHtml(s.id) + '\',this)" title="Run now">Run now</button>' +
           '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:' + (s.enabled ? 'var(--yellow)' : 'var(--green)') + ';border-color:' + (s.enabled ? 'var(--yellow)' : 'var(--green)') + ';margin-right:4px" onclick="event.stopPropagation();toggleScheduleEnabled(\'' + escHtml(s.id) + '\',' + !s.enabled + ')" title="' + (s.enabled ? 'Disable' : 'Enable') + '">' + (s.enabled ? '&#x23F8;' : '&#x25B6;') + '</button>' +
           '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--blue);border-color:var(--blue);margin-right:4px" onclick="event.stopPropagation();openEditScheduleModal(\'' + escHtml(s.id) + '\')" title="Edit">&#x270E;</button>' +
           '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--red);border-color:var(--red)" onclick="event.stopPropagation();deleteSchedule(\'' + escHtml(s.id) + '\')" title="Delete">&#x2715;</button>' +
@@ -336,6 +337,7 @@ function openScheduleDetail(id) {
 
   document.getElementById('modal-title').innerHTML = escHtml(s.title || s.id) +
     ' <div style="display:flex;gap:4px;margin-top:4px">' +
+      '<button class="pr-pager-btn" style="font-size:10px;padding:2px 10px;color:var(--green)" onclick="runScheduleNow(\'' + escHtml(s.id) + '\',this)">Run now</button>' +
       '<button class="pr-pager-btn" style="font-size:10px;padding:2px 10px;color:var(--blue)" onclick="closeModal();openEditScheduleModal(\'' + escHtml(s.id) + '\')">Edit</button>' +
       '<button class="pr-pager-btn" style="font-size:10px;padding:2px 10px;color:' + (s.enabled ? 'var(--yellow)' : 'var(--green)') + '" onclick="toggleScheduleEnabled(\'' + escHtml(s.id) + '\',' + !s.enabled + ');closeModal()">' + (s.enabled ? 'Disable' : 'Enable') + '</button>' +
       '<button class="pr-pager-btn" style="font-size:10px;padding:2px 10px;color:var(--red)" onclick="deleteSchedule(\'' + escHtml(s.id) + '\');closeModal()">Delete</button>' +
@@ -544,6 +546,26 @@ async function toggleScheduleEnabled(id, enabled) {
   } catch (e) { _showScheduleError('Toggle error: ' + e.message); refresh(); }
 }
 
+async function runScheduleNow(id, btn) {
+  if (btn) { btn.textContent = 'Running...'; btn.style.pointerEvents = 'none'; btn.style.opacity = '0.6'; }
+  try {
+    const res = await fetch('/api/schedules/run-now', {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ id })
+    });
+    if (res.ok) {
+      showToast('cmd-toast', 'Schedule run queued', true);
+      refresh();
+    } else {
+      const d = await res.json().catch(() => ({}));
+      showToast('cmd-toast', 'Run failed: ' + (d.error || 'unknown'), false);
+    }
+  } catch (e) {
+    showToast('cmd-toast', 'Run error: ' + e.message, false);
+  }
+  if (btn) { btn.textContent = 'Run now'; btn.style.pointerEvents = ''; btn.style.opacity = ''; }
+}
+
 async function deleteSchedule(id) {
   if (!confirm('Delete scheduled task "' + id + '"?')) return;
   showToast('cmd-toast', 'Schedule deleted', true);
@@ -562,4 +584,4 @@ async function deleteSchedule(id) {
 // Expose _generateScheduleId globally for the inline oninput handler
 window._generateScheduleId = _generateScheduleId;
 
-window.MinionsSchedules = { renderSchedules, openCreateScheduleModal, openEditScheduleModal, openScheduleDetail, submitSchedule, toggleScheduleEnabled, deleteSchedule, _cronToHuman, _parseNaturalCron, _toggleCronMode, _quickSelectDays, _toggleDayPill, _updateCronPreview, _schedPrev, _schedNext, _schedSetView };
+window.MinionsSchedules = { renderSchedules, openCreateScheduleModal, openEditScheduleModal, openScheduleDetail, submitSchedule, toggleScheduleEnabled, runScheduleNow, deleteSchedule, _cronToHuman, _parseNaturalCron, _toggleCronMode, _quickSelectDays, _toggleDayPill, _updateCronPreview, _schedPrev, _schedNext, _schedSetView };

package/dashboard.js

@@ -126,6 +126,124 @@ function copyWorkItemPrFields(item, input, pr = null) {
   if (pr?.title || input.prTitle) item.prTitle = pr?.title || input.prTitle;
   if (pr?.url || input.prUrl) item.prUrl = pr?.url || input.prUrl;
 }
+
+function normalizeWorkItemDedupText(value) {
+  return String(value == null ? '' : value)
+    .replace(/\r\n/g, '\n')
+    .replace(/[ \t]+$/gm, '')
+    .trim();
+}
+
+function resolveWorkItemDedupProject(item, wiPath = '') {
+  const projectName = normalizeWorkItemDedupText(item?.project || item?._project || item?._source);
+  if (projectName) {
+    const namedProject = PROJECTS.find(p => p?.name === projectName);
+    if (namedProject) return namedProject;
+  }
+  if (!wiPath) return null;
+  const resolvedWiPath = path.resolve(wiPath);
+  return PROJECTS.find(p => path.resolve(shared.projectWorkItemsPath(p)) === resolvedWiPath) || null;
+}
+
+function getWorkItemPrRefCandidates(item) {
+  return [
+    item?.targetPr,
+    item?.pr,
+    item?.prId,
+    item?.pullRequest,
+    item?.sourcePr,
+    item?.prUrl,
+    item?.pr_id,
+    item?.prNumber,
+  ].filter(value => value != null && value !== '');
+}
+
+function normalizeWorkItemDedupPrIdentity(item, project = null) {
+  if (!item || typeof item !== 'object') return '';
+  const candidates = getWorkItemPrRefCandidates(item);
+  for (const candidate of candidates) {
+    const scoped = shared.getPrScopeInfo(candidate);
+    if (scoped) return `${scoped.scope}#${scoped.prNumber}`;
+  }
+  const prNumber = candidates.reduce((found, candidate) => (
+    found ?? shared.getPrNumber(candidate)
+  ), null);
+  if (project && prNumber != null) {
+    const canonical = shared.getCanonicalPrId(project, prNumber);
+    if (canonical) return canonical;
+  }
+  if (prNumber != null) return `PR-${prNumber}`;
+  const prRef = getWorkItemPrRef(item) || item.pr_id || item.targetPr || item.prUrl || '';
+  return normalizeWorkItemDedupText(prRef).toLowerCase();
+}
+
+function workItemCreateFingerprint(item, options = {}) {
+  const project = resolveWorkItemDedupProject(item, options.wiPath);
+  return {
+    title: normalizeWorkItemDedupText(item?.title),
+    type: routing.normalizeWorkType(item?.type || item?.workType, WORK_TYPE.IMPLEMENT),
+    priority: normalizeWorkItemDedupText(item?.priority || 'medium').toLowerCase(),
+    description: normalizeWorkItemDedupText(item?.description),
+    prIdentity: normalizeWorkItemDedupPrIdentity(item, project),
+  };
+}
+
+function isActiveWorkItemCreateStatus(status) {
+  return status === WI_STATUS.PENDING || status === WI_STATUS.DISPATCHED || status === WI_STATUS.QUEUED;
+}
+
+function isWithinWorkItemCreateDedupWindow(item, nowMs, windowMs) {
+  const createdMs = Date.parse(item?.created || item?.createdAt || item?.created_at || '');
+  if (!Number.isFinite(createdMs)) return true;
+  return nowMs - createdMs <= windowMs;
+}
+
+function findDuplicateWorkItemCreate(items, candidate, options = {}) {
+  if (!Array.isArray(items)) return null;
+  const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+  const windowMs = Number.isFinite(options.windowMs) ? options.windowMs : shared.ENGINE_DEFAULTS.workItemCreateDedupWindowMs;
+  const candidateFingerprint = workItemCreateFingerprint(candidate, options);
+  return items.find(item => {
+    if (!isActiveWorkItemCreateStatus(item?.status)) return false;
+    if (!isWithinWorkItemCreateDedupWindow(item, nowMs, windowMs)) return false;
+    const existingFingerprint = workItemCreateFingerprint(item, options);
+    return existingFingerprint.title === candidateFingerprint.title &&
+      existingFingerprint.type === candidateFingerprint.type &&
+      existingFingerprint.priority === candidateFingerprint.priority &&
+      existingFingerprint.description === candidateFingerprint.description &&
+      existingFingerprint.prIdentity === candidateFingerprint.prIdentity;
+  }) || null;
+}
+
+function createWorkItemWithDedup(wiPath, item, options = {}) {
+  let result = null;
+  mutateWorkItems(wiPath, items => {
+    const existing = findDuplicateWorkItemCreate(items, item, { ...options, wiPath });
+    if (existing) {
+      result = { created: false, item: existing, duplicateOf: existing.id };
+      return items;
+    }
+    items.push(item);
+    result = { created: true, item };
+    return items;
+  });
+  return result || { created: false, item: null };
+}
+
+function resolveWorkItemsCreateTarget(projectName, projects = PROJECTS) {
+  const project = String(projectName || '').trim();
+  let targetProject = null;
+  if (project) {
+    targetProject = projects.find(p => p.name === project) || (projects.length > 0 ? projects[0] : null);
+    if (!targetProject) return { error: 'No projects configured' };
+  } else if (projects.length === 1) {
+    targetProject = projects[0];
+  }
+  return {
+    project: targetProject,
+    wiPath: targetProject ? shared.projectWorkItemsPath(targetProject) : path.join(MINIONS_DIR, 'work-items.json'),
+  };
+}
 function linkPullRequestForTracking({ url, title, project: projectName, autoObserve, context, workItemId }, config = CONFIG, options = {}) {
   if (!url) {
     const err = new Error('url required');
@@ -1531,20 +1649,21 @@ async function executeCCActions(actions) {
           // Mark oneShot so any discovered PR is tagged _contextOnly (skips eval loop).
           const ccOneShotTypes = new Set(['review', 'explore', 'test']);
           const isOneShot = action.oneShot === true || (action.oneShot !== false && ccOneShotTypes.has(workType));
-          shared.mutateJsonFileLocked(wiPath, items => {
-            if (!Array.isArray(items)) items = [];
-            const item = {
-              id, title: action.title, type: workType,
-              priority: action.priority || 'medium', description: action.description || '',
-              status: WI_STATUS.PENDING, created: new Date().toISOString(),
-              createdBy: 'command-center', project: targetProject?.name || project,
-              ...(agentHints.length ? { preferred_agent: agentHints[0], agents: agentHints } : {}),
-              ...(isOneShot ? { oneShot: true } : {}),
-            };
-            copyWorkItemPrFields(item, action, linkedPr);
-            items.push(item);
-            return items;
-          }, { defaultValue: [] });
+          const item = {
+            id, title: action.title.trim(), type: workType,
+            priority: action.priority || 'medium', description: action.description || '',
+            status: WI_STATUS.PENDING, created: new Date().toISOString(),
+            createdBy: 'command-center', project: targetProject?.name || project,
+            ...(agentHints.length ? { preferred_agent: agentHints[0], agents: agentHints } : {}),
+            ...(isOneShot ? { oneShot: true } : {}),
+          };
+          copyWorkItemPrFields(item, action, linkedPr);
+          const createResult = createWorkItemWithDedup(wiPath, item);
+          if (!createResult.created) {
+            const duplicateId = createResult.duplicateOf || createResult.item?.id;
+            results.push({ type: action.type, id: duplicateId, ok: true, duplicate: true, duplicateOf: duplicateId });
+            break;
+          }
           results.push({ type: action.type, id, ok: true });
 
           // Pre-flight routing check: warn the user if no agent is currently available so the new
@@ -2840,22 +2959,17 @@ const server = http.createServer(async (req, res) => {
     try {
       const body = await readBody(req);
       if (!body.title || !body.title.trim()) return jsonReply(res, 400, { error: 'title is required' });
-      let wiPath;
-      if (body.project) {
-        // Write to project-specific queue
-        const targetProject = PROJECTS.find(p => p.name === body.project) || (PROJECTS.length > 0 ? PROJECTS[0] : null);
-        if (!targetProject) return jsonReply(res, 400, { error: 'No projects configured' });
-        wiPath = shared.projectWorkItemsPath(targetProject);
-      } else {
-        // Write to central queue — agent decides which project
-        wiPath = path.join(MINIONS_DIR, 'work-items.json');
-      }
+      const target = resolveWorkItemsCreateTarget(body.project);
+      if (target.error) return jsonReply(res, 400, { error: target.error });
+      const wiPath = target.wiPath;
+      const targetProject = target.project;
       const id = 'W-' + shared.uid();
       const item = {
         id, title: body.title.trim(), type: routing.normalizeWorkType(body.type, WORK_TYPE.IMPLEMENT),
         priority: body.priority || 'medium', description: body.description || '',
         status: WI_STATUS.PENDING, created: new Date().toISOString(), createdBy: 'dashboard',
       };
+      if (targetProject) item.project = targetProject.name;
       if (body.scope) item.scope = body.scope;
       // Agent assignment normalization: `agent` and `agents` are routing hints.
       // Use agentLock/hardAgent only for the rare case where an item must wait
@@ -2870,18 +2984,11 @@ const server = http.createServer(async (req, res) => {
       if (body.skipPr) item.skipPr = true;
       if (body.oneShot) item.oneShot = true;
       copyWorkItemPrFields(item, body);
-      let dupId = null;
-      mutateJsonFileLocked(wiPath, (items) => {
-        if (!Array.isArray(items)) items = [];
-        const existing = items.find(i =>
-          i.title === item.title &&
-          (i.status === WI_STATUS.PENDING || i.status === WI_STATUS.DISPATCHED || i.status === WI_STATUS.QUEUED)
-        );
-        if (existing) { dupId = existing.id; return items; }
-        items.push(item);
-        return items;
-      });
-      if (dupId) return jsonReply(res, 200, { ok: true, id: dupId, duplicate: true });
+      const createResult = createWorkItemWithDedup(wiPath, item);
+      if (!createResult.created) {
+        const duplicateId = createResult.duplicateOf || createResult.item?.id;
+        return jsonReply(res, 200, { ok: true, id: duplicateId, duplicate: true, duplicateOf: duplicateId });
+      }
       return jsonReply(res, 200, { ok: true, id });
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
@@ -5446,6 +5553,69 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     return jsonReply(res, 200, { ok: true });
   }
 
+  async function handleSchedulesRunNow(req, res) {
+    const body = await readBody(req);
+    const { id } = body;
+    if (!id) return jsonReply(res, 400, { error: 'id required' });
+
+    reloadConfig();
+    const sched = (CONFIG.schedules || []).find(s => s.id === id);
+    if (!sched) return jsonReply(res, 404, { error: 'Schedule not found' });
+
+    const schedulerMod = require('./engine/scheduler');
+    let item;
+    try {
+      item = schedulerMod.createScheduledWorkItem(sched);
+    } catch (e) {
+      return jsonReply(res, 400, { error: e.message });
+    }
+
+    let meeting = null;
+    if (item.type === WORK_TYPE.MEETING) {
+      const { createMeeting } = require('./engine/meeting');
+      meeting = createMeeting({
+        title: item.title,
+        agenda: item.description,
+        participants: Array.isArray(sched.participants) ? sched.participants : [],
+      });
+    } else {
+      const centralPath = path.join(MINIONS_DIR, 'work-items.json');
+      let duplicate = null;
+      mutateJsonFileLocked(centralPath, (items) => {
+        if (!Array.isArray(items)) items = [];
+        duplicate = items.find(i =>
+          i._scheduleId === item._scheduleId &&
+          i.status !== WI_STATUS.DONE &&
+          i.status !== WI_STATUS.FAILED
+        );
+        if (!duplicate) items.push(item);
+        return items;
+      }, { defaultValue: [] });
+      if (duplicate) {
+        return jsonReply(res, 409, {
+          error: 'Schedule already has an active work item',
+          id: duplicate.id,
+          scheduleId: sched.id,
+        });
+      }
+    }
+
+    const runEntry = schedulerMod.recordScheduleRun(sched.id, item.id);
+    try {
+      shared.mutateControl(control => ({ ...control, _wakeupAt: Date.now() }));
+    } catch (e) {
+      shared.log('warn', `Schedule run-now wakeup failed for ${sched.id}: ${e.message}`);
+    }
+    invalidateStatusCache();
+    return jsonReply(res, 200, {
+      ok: true,
+      id: item.id,
+      scheduleId: sched.id,
+      lastRun: runEntry?.lastRun || null,
+      ...(meeting ? { meetingId: meeting.id } : {}),
+    });
+  }
+
   async function handleSchedulesParseNatural(req, res) {
     const body = await readBody(req);
     const { text } = body;
@@ -6427,6 +6597,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { method: 'POST', path: '/api/schedules', desc: 'Create a new schedule', params: 'cron, title, id?, type?, project?, agent?, description?, priority?, enabled?', handler: handleSchedulesCreate },
     { method: 'POST', path: '/api/schedules/update', desc: 'Update an existing schedule', params: 'id, cron?, title?, type?, project?, agent?, description?, priority?, enabled?', handler: handleSchedulesUpdate },
     { method: 'POST', path: '/api/schedules/delete', desc: 'Delete a schedule', params: 'id', handler: handleSchedulesDelete },
+    { method: 'POST', path: '/api/schedules/run-now', desc: 'Manually enqueue the work item for a schedule', params: 'id', handler: handleSchedulesRunNow },
 
     // Watches
     { method: 'GET', path: '/api/watches', desc: 'List all watches', handler: handleWatchesList },
@@ -6757,6 +6928,9 @@ module.exports = {
   _resolveSkillReadPath,
   DOC_CHAT_DOCUMENT_DELIMITER,
   _ccValidateAction,
+  _findDuplicateWorkItemCreate: findDuplicateWorkItemCreate,
+  _createWorkItemWithDedup: createWorkItemWithDedup,
+  _resolveWorkItemsCreateTarget: resolveWorkItemsCreateTarget,
   executeCCActions,
 };
 

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-04T07:34:20.525Z"
+  "cachedAt": "2026-05-04T07:52:35.839Z"
 }

package/engine/scheduler.js

@@ -140,6 +140,42 @@ function shouldRunNow(schedule, lastRunAt) {
   return true;
 }
 
+function createScheduledWorkItem(sched) {
+  if (!sched || !sched.id || !sched.title) {
+    throw new Error('schedule id and title are required');
+  }
+  const workItemId = `sched-${sched.id}-${Date.now()}`;
+  return {
+    id: workItemId,
+    title: resolveScheduleTemplateVars(sched.title),
+    type: routing.normalizeWorkType(sched.type, WORK_TYPE.IMPLEMENT),
+    priority: sched.priority || 'medium',
+    description: resolveScheduleTemplateVars(sched.description || sched.title),
+    status: WI_STATUS.PENDING,
+    created: ts(),
+    createdBy: 'scheduler',
+    agent: sched.agent || null,
+    ...(sched.agentLock === true || sched.hardAgent === true ? { agentLock: true } : {}),
+    project: sched.project || null,
+    _scheduleId: sched.id,
+  };
+}
+
+function writeScheduleRunEntry(runs, scheduleId, workItemId) {
+  const existing = typeof runs[scheduleId] === 'object' && runs[scheduleId] ? runs[scheduleId] : {};
+  runs[scheduleId] = { ...existing, lastRun: ts(), lastWorkItemId: workItemId };
+  return runs[scheduleId];
+}
+
+function recordScheduleRun(scheduleId, workItemId) {
+  let entry = null;
+  mutateJsonFileLocked(SCHEDULE_RUNS_PATH, (runs) => {
+    entry = writeScheduleRunEntry(runs, scheduleId, workItemId);
+    return runs;
+  }, { defaultValue: {} });
+  return entry;
+}
+
 /**
  * Discover work items from configured schedules.
  * @param {object} config -- full config object
@@ -164,21 +200,8 @@ function discoverScheduledWork(config) {
       // Substitute schedule-time template vars (e.g. {{date}}) before the work
       // item is written — single-pass playbook rendering can't reach placeholders
       // embedded inside task_description, so they must be resolved up front.
-      const workItemId = `sched-${sched.id}-${Date.now()}`;
-      work.push({
-        id: workItemId,
-        title: resolveScheduleTemplateVars(sched.title),
-        type: routing.normalizeWorkType(sched.type, WORK_TYPE.IMPLEMENT),
-        priority: sched.priority || 'medium',
-        description: resolveScheduleTemplateVars(sched.description || sched.title),
-        status: WI_STATUS.PENDING,
-        created: ts(),
-        createdBy: 'scheduler',
-        agent: sched.agent || null,
-        ...(sched.agentLock === true || sched.hardAgent === true ? { agentLock: true } : {}),
-        project: sched.project || null,
-        _scheduleId: sched.id,
-      });
+      const workItem = createScheduledWorkItem(sched);
+      work.push(workItem);
 
       // Record run time AND work-item ID at dispatch time — preserve existing
       // completion fields (lastResult, lastCompletedAt). Writing lastWorkItemId
@@ -186,12 +209,20 @@ function discoverScheduledWork(config) {
       // the dispatched work item crashes or the engine restarts before
       // lifecycle.runPostCompletionHooks runs. This is the fix that closes
       // the double-fire window alongside the same-minute guard (W-mo3zu273f8tm).
-      const existing = typeof runs[sched.id] === 'object' && runs[sched.id] ? runs[sched.id] : {};
-      runs[sched.id] = { ...existing, lastRun: ts(), lastWorkItemId: workItemId };
+      writeScheduleRunEntry(runs, sched.id, workItem.id);
     }
   }, { defaultValue: {} });
 
   return work;
 }
 
-module.exports = { parseCronExpr, parseCronField, shouldRunNow, discoverScheduledWork, resolveScheduleTemplateVars, SCHEDULE_RUNS_PATH };
+module.exports = {
+  parseCronExpr,
+  parseCronField,
+  shouldRunNow,
+  discoverScheduledWork,
+  createScheduledWorkItem,
+  recordScheduleRun,
+  resolveScheduleTemplateVars,
+  SCHEDULE_RUNS_PATH,
+};

package/engine/shared.js

@@ -770,6 +770,7 @@ const ENGINE_DEFAULTS = {
   worktreeCreateRetries: 1, // retry once on transient timeout/lock races
   worktreeRoot: '../worktrees',
   worktreeCountCacheTtl: 30000, // 30s — TTL for cached _countWorktrees() result in dashboard
+  workItemCreateDedupWindowMs: 15 * 60 * 1000, // 15min — collapse duplicate CC/API create races
   idleAlertMinutes: 15,
   fanOutTimeout: null, // falls back to agentTimeout
   restartGracePeriod: 1200000, // 20min
@@ -1976,6 +1977,15 @@ function normalizePrLinkItems(value) {
   return [...new Set(items.filter(item => typeof item === 'string' && item))];
 }
 
+function isAutoManagedPrRecord(pr) {
+  if (!pr || typeof pr !== 'object' || pr._contextOnly === true) return false;
+  if (normalizePrLinkItems(pr.prdItems).length > 0) return true;
+  if (pr._autoObserve === true) return true;
+  if (pr.sourcePlan || pr.itemType) return true;
+  const agent = String(pr.agent || '').trim().toLowerCase();
+  return !!agent && agent !== 'human';
+}
+
 function mergePrLinkItems(links, prId, itemIds) {
   if (!prId) return;
   const merged = new Set([...(links[prId] || []), ...normalizePrLinkItems(itemIds)]);
@@ -2145,14 +2155,19 @@ function upsertPullRequestRecord(prPath, entry, { project = null, itemId = null,
     } else {
       target.id = canonicalId;
       if (prNumber != null) target.prNumber = prNumber;
+      const targetWasAutoManaged = isAutoManagedPrRecord(target);
       for (const key of ['url', 'title', 'description', 'agent', 'branch', 'reviewStatus', 'status', 'created', 'sourcePlan', 'itemType']) {
         if (normalizedEntry[key] != null && normalizedEntry[key] !== '' && (target[key] == null || target[key] === '')) {
           target[key] = normalizedEntry[key];
         }
       }
-      for (const key of ['_manual', '_contextOnly', '_autoObserve', '_context']) {
+      for (const key of ['_manual', '_autoObserve', '_context']) {
         if (normalizedEntry[key] != null) target[key] = normalizedEntry[key];
       }
+      if (normalizedEntry._contextOnly != null) {
+        const wouldDemoteManagedPr = normalizedEntry._contextOnly === true && targetWasAutoManaged;
+        if (!wouldDemoteManagedPr) target._contextOnly = normalizedEntry._contextOnly;
+      }
     }
     target.prdItems = normalizePrLinkItems(target.prdItems || []);
     for (const linkedItemId of linkedItemIds) {

package/package.json

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