@yemi33/minions 0.1.1806 → 0.1.1808

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.1808 (2026-05-08)
+
+### Fixes
+-  Plan-to-PRD conversion can override explicit plan project with contextual project (#2235)
+
+## 0.1.1807 (2026-05-08)
+
+### Other
+- docs: clarify detached process handoff
+
 ## 0.1.1806 (2026-05-08)
 
 ### Fixes

package/dashboard.js

@@ -5506,12 +5506,14 @@ const server = http.createServer(async (req, res) => {
       shared.sanitizePath(body.file, PLANS_DIR);
       const planPath = path.join(MINIONS_DIR, 'plans', body.file);
       if (!fs.existsSync(planPath)) return jsonReply(res, 404, { error: 'plan file not found' });
+      const planContent = fs.readFileSync(planPath, 'utf8');
+      const declaredProject = shared.extractPlanDeclaredProject(planContent);
 
       const queued = shared.queuePlanToPrd({
         planFile: body.file,
         title: 'Convert plan to PRD: ' + body.file.replace('.md', ''),
         description: 'Plan file: plans/' + body.file,
-        project: body.project || '', createdBy: 'dashboard:execute',
+        project: declaredProject || body.project || '', createdBy: 'dashboard:execute',
       });
       if (!queued) return jsonReply(res, 200, { ok: true, alreadyQueued: true });
       invalidateStatusCache();

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-08T18:43:02.635Z"
+  "cachedAt": "2026-05-08T20:57:25.233Z"
 }

package/engine/playbook.js

@@ -332,14 +332,29 @@ function validatePlaybookVars(playbookName, vars) {
  * @param {string} playbookType — playbook type name (e.g. 'implement', 'review')
  * @returns {string} absolute path to the playbook file
  */
+function isSafeProjectPlaybookName(projectName) {
+  const name = String(projectName || '').trim();
+  return !!name &&
+    !name.includes('\0') &&
+    !name.includes('..') &&
+    !/[\\/]/.test(name) &&
+    !path.isAbsolute(name) &&
+    !/^[a-zA-Z]:/.test(name);
+}
+
 function resolvePlaybookPath(projectName, playbookType) {
   if (projectName) {
-    const localPath = path.join(MINIONS_DIR, 'projects', projectName, 'playbooks', `${playbookType}.md`);
-    try {
-      fs.accessSync(localPath, fs.constants.R_OK);
-      log('info', `Using project-local playbook: projects/${projectName}/playbooks/${playbookType}.md`);
-      return localPath;
-    } catch { /* no local override — fall through to global */ }
+    const projectDirName = String(projectName).trim();
+    if (isSafeProjectPlaybookName(projectDirName)) {
+      const localPath = path.join(MINIONS_DIR, 'projects', projectDirName, 'playbooks', `${playbookType}.md`);
+      try {
+        fs.accessSync(localPath, fs.constants.R_OK);
+        log('info', `Using project-local playbook: projects/${projectDirName}/playbooks/${playbookType}.md`);
+        return localPath;
+      } catch { /* no local override — fall through to global */ }
+    } else {
+      log('warn', `Skipping project-local playbook lookup for unsafe project name: ${projectDirName}`);
+    }
   }
   return path.join(PLAYBOOKS_DIR, `${playbookType}.md`);
 }

package/engine/shared.js

@@ -1579,6 +1579,24 @@ function queuePlanToPrd({ planFile, prdFile, title, description, project, create
   }, { defaultValue: [] });
   return queued;
 }
+
+function extractPlanDeclaredProject(planContent) {
+  if (typeof planContent !== 'string' || !planContent.trim()) return '';
+  const lines = planContent.split(/\r?\n/).slice(0, 80);
+  for (const rawLine of lines) {
+    const line = rawLine
+      .replace(/^\s*[-*]\s+/, '')
+      .replace(/\*\*/g, '')
+      .trim();
+    const match = line.match(/^Project\s*:\s*(.+)$/i);
+    if (!match) continue;
+    let value = match[1].trim();
+    value = value.replace(/\s+#.*$/, '').trim();
+    value = value.replace(/^["'`]+|["'`]+$/g, '').trim();
+    return value;
+  }
+  return '';
+}
 const DISPATCH_RESULT = { SUCCESS: 'success', ERROR: 'error', TIMEOUT: 'timeout' };
 const PIPELINE_STATUS = {
   PENDING: 'pending', RUNNING: 'running', COMPLETED: 'completed',
@@ -3257,7 +3275,7 @@ module.exports = {
   runtimeConfigWarnings,
   projectWorkSourceWarnings,
   backfillProjectWorkSourceDefaults,
-  WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, WORK_TYPE, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, PR_POLLABLE_STATUSES, PR_PENDING_REASON, DISPATCH_RESULT, trackReviewMetric, queuePlanToPrd,
+  WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, WORK_TYPE, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, PR_POLLABLE_STATUSES, PR_PENDING_REASON, DISPATCH_RESULT, trackReviewMetric, queuePlanToPrd, extractPlanDeclaredProject,
   WATCH_STATUS, WATCH_TARGET_TYPE, WATCH_CONDITION, WATCH_ABSOLUTE_CONDITIONS,
   PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, AGENT_STATUS,
   FAILURE_CLASS, ESCALATION_POLICY, COMPLETION_FIELDS,
@@ -3302,6 +3320,7 @@ module.exports = {
   getAdoOrgBase,
   sanitizePath,
   sanitizeBranch,
+  safeSlugComponent,
   buildWorktreeDirName, // exported for testing
   isPathInside,
   isPathInsideOrEqual,

package/engine.js

@@ -1978,6 +1978,20 @@ function buildWiDescription(item, planFile) {
   return `${item.description || ''}\n\n**Plan:** ${planFile}\n**Plan Item:** ${item.id}\n**Complexity:** ${complexity}${criteria ? '\n\n**Acceptance Criteria:**\n' + criteria : ''}`;
 }
 
+function safePrdProjectSlug(projectName) {
+  const slug = shared.safeSlugComponent(projectName || 'project', 80)
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return slug || 'project';
+}
+
+function safePrdFilenameForProject(projectName, suffix) {
+  const fileName = `${safePrdProjectSlug(projectName)}-${suffix}.json`;
+  shared.sanitizePath(fileName, PRD_DIR);
+  return fileName;
+}
+
 function materializePlansAsWorkItems(config) {
   if (!fs.existsSync(PRD_DIR)) { try { fs.mkdirSync(PRD_DIR, { recursive: true }); } catch (e) { log('warn', 'create PRD directory: ' + e.message); } }
   const writePrdLocked = (fileName, data) => {
@@ -1990,6 +2004,100 @@ function materializePlansAsWorkItems(config) {
       return mutator(current) || current;
     }, { defaultValue: fallback || {}, ...options });
   };
+  const declaredProjectPrdFilename = (fileName, projectName) => {
+    const match = String(fileName || '').match(/-(\d{4}-\d{2}-\d{2}(?:-\d+)?)\.json$/);
+    if (!match) return null;
+    return safePrdFilenameForProject(projectName, match[1]);
+  };
+  const migratePrdFilenameReferences = (oldFileName, newFileName) => {
+    if (!oldFileName || !newFileName || oldFileName === newFileName) return 0;
+    let migrated = 0;
+    const wiPaths = new Set([path.join(MINIONS_DIR, 'work-items.json')]);
+    for (const project of getProjects(config)) wiPaths.add(projectWorkItemsPath(project));
+    for (const wiPath of wiPaths) {
+      if (!fs.existsSync(wiPath)) continue;
+      mutateWorkItems(wiPath, (items) => {
+        for (const wi of items) {
+          if (!wi || typeof wi !== 'object') continue;
+          if (wi.sourcePlan === oldFileName) {
+            wi.sourcePlan = newFileName;
+            migrated++;
+          }
+          if (wi._artifacts?.sourcePlan === oldFileName) {
+            wi._artifacts.sourcePlan = newFileName;
+            migrated++;
+          }
+        }
+        return items;
+      });
+    }
+    if (fs.existsSync(DISPATCH_PATH)) {
+      mutateDispatch((dispatch) => {
+        for (const queue of ['pending', 'active', 'completed']) {
+          for (const entry of dispatch[queue] || []) {
+            const metaItem = entry?.meta?.item;
+            if (!metaItem || typeof metaItem !== 'object') continue;
+            if (metaItem.sourcePlan === oldFileName) {
+              metaItem.sourcePlan = newFileName;
+              migrated++;
+            }
+            if (metaItem._prdFilename === oldFileName) {
+              metaItem._prdFilename = newFileName;
+              migrated++;
+            }
+          }
+        }
+        return dispatch;
+      });
+    }
+    return migrated;
+  };
+  const enforceDeclaredPlanProject = (fileName, currentPlan) => {
+    if (!currentPlan?.source_plan) return { fileName, plan: currentPlan };
+    let declaredProject = '';
+    try {
+      declaredProject = shared.extractPlanDeclaredProject(safeRead(path.join(PLANS_DIR, currentPlan.source_plan)) || '');
+    } catch (e) {
+      log('warn', `Plan project enforcement: could not read source plan ${currentPlan.source_plan}: ${e.message}`);
+    }
+    if (!declaredProject) return { fileName, plan: currentPlan };
+
+    let changed = false;
+    const normalizedPlan = mutatePrdLocked(fileName, currentPlan, (planData) => {
+      if (planData.project !== declaredProject) {
+        planData.project = declaredProject;
+        changed = true;
+      }
+      if (Array.isArray(planData.missing_features)) {
+        for (const feature of planData.missing_features) {
+          if (feature && feature.project !== declaredProject) {
+            feature.project = declaredProject;
+            changed = true;
+          }
+        }
+      }
+      return planData;
+    }, { skipWriteIfUnchanged: true });
+
+    let nextFileName = fileName;
+    const desiredFileName = declaredProjectPrdFilename(fileName, declaredProject);
+    if (desiredFileName && desiredFileName.toLowerCase() !== String(fileName).toLowerCase()) {
+      const fromPath = path.join(PRD_DIR, fileName);
+      const desiredPath = shared.sanitizePath(desiredFileName, PRD_DIR);
+      const toPath = shared.uniquePath(desiredPath);
+      try {
+        fs.renameSync(fromPath, toPath);
+        nextFileName = path.basename(toPath);
+        const migrated = migratePrdFilenameReferences(fileName, nextFileName);
+        if (migrated > 0) log('info', `Plan project enforcement: migrated ${migrated} PRD reference(s) from ${fileName} to ${nextFileName}`);
+        changed = true;
+      } catch (e) {
+        log('warn', `Plan project enforcement: could not rename ${fileName} to ${path.basename(toPath)}: ${e.message}`);
+      }
+    }
+    if (changed) log('info', `Plan project enforcement: preserved declared project "${declaredProject}" for ${nextFileName}`);
+    return { fileName: nextFileName, plan: normalizedPlan };
+  };
 
   // Enforce: PRDs must be .json — auto-rename .md files that contain valid PRD JSON
   // Check both prd/ and plans/ (agents may still write JSON to plans/)
@@ -2036,12 +2144,13 @@ function materializePlansAsWorkItems(config) {
   // Regex for detecting sequential PRD item IDs (P-001, P-002) — hoisted outside loop
   const SEQUENTIAL_ID_RE = /^P-?\d+$/;
 
-  for (const file of planFiles) {
+  for (let file of planFiles) {
     // safeJsonNoRestore — if a PRD was archived between readdir and this
     // read, do not auto-resurrect it from a stale .backup sidecar
     // (W-mouptdh1000h9f39).
     let plan = safeJsonNoRestore(path.join(PRD_DIR, file));
     if (!plan?.missing_features) continue;
+    ({ fileName: file, plan } = enforceDeclaredPlanProject(file, plan));
 
     // ID collision prevention: remap sequential IDs (P-001, P-002) to globally unique P-<uid> IDs.
     // Agents are instructed to use P-<uuid> format but sometimes generate sequential IDs,
@@ -3576,7 +3685,7 @@ function discoverCentralWorkItems(config) {
   const items = safeJson(centralPath) || [];
   const projects = getProjects(config);
   const dispatchProjects = getCentralDispatchProjects(projects);
-  const projectsByName = new Map(dispatchProjects.map(p => [p.name, p]));
+  const projectsByName = new Map(dispatchProjects.map(p => [String(p.name || '').toLowerCase(), p]));
   const newWork = [];
   // Collect mutations to apply atomically inside lock callback (avoids TOCTOU)
   const mutations = new Map(); // item.id → { field: value, ... }
@@ -3706,9 +3815,32 @@ function discoverCentralWorkItems(config) {
 
       const agentName = config.agents[agentId]?.name || agentId;
       const agentRole = config.agents[agentId]?.role || 'Agent';
+      let planFileContent = null;
+      let planReadError = null;
+      let declaredPlanProject = '';
+      if (workType === WORK_TYPE.PLAN_TO_PRD && item.planFile) {
+        const planPath = path.join(PLANS_DIR, item.planFile);
+        try {
+          planFileContent = fs.readFileSync(planPath, 'utf8');
+          declaredPlanProject = shared.extractPlanDeclaredProject(planFileContent);
+        } catch (e) {
+          planReadError = e;
+        }
+      }
       const firstProject = dispatchProjects[0];
-      const requestedProjectName = typeof item.project === 'string' ? item.project : item.project?.name;
-      const targetProject = (requestedProjectName && projectsByName.get(requestedProjectName)) || firstProject;
+      const requestedProjectName = declaredPlanProject || (typeof item.project === 'string' ? item.project : item.project?.name);
+      const requestedProject = requestedProjectName ? projectsByName.get(String(requestedProjectName).toLowerCase()) : null;
+      const targetProject = requestedProject || (declaredPlanProject
+        ? { name: declaredPlanProject, localPath: '', repoName: declaredPlanProject, mainBranch: firstProject?.mainBranch || 'main' }
+        : firstProject);
+      if (declaredPlanProject) {
+        const projectMutation = { project: targetProject.name, _declaredPlanProject: declaredPlanProject };
+        if (!requestedProject) projectMutation._declaredPlanProjectMissing = true;
+        mutations.set(item.id, Object.assign(mutations.get(item.id) || {}, projectMutation));
+        if (!requestedProject) {
+          log('warn', `plan-to-prd: plan ${item.planFile} declares project "${declaredPlanProject}" but no configured project matches; preserving the declared project name with no project_path`);
+        }
+      }
 
       // Branch mutex: skip if target branch is locked by an active dispatch
       const centralBranch = item.branch || item.featureBranch || `work/${item.id}`;
@@ -3776,16 +3908,16 @@ function discoverCentralWorkItems(config) {
       if (workType === WORK_TYPE.PLAN_TO_PRD && item.planFile) {
         if (!fs.existsSync(PLANS_DIR)) fs.mkdirSync(PLANS_DIR, { recursive: true });
         if (!fs.existsSync(PRD_DIR)) fs.mkdirSync(PRD_DIR, { recursive: true });
-        const planPath = path.join(PLANS_DIR, item.planFile);
-        try {
-          vars.plan_content = fs.readFileSync(planPath, 'utf8');
-        } catch (e) {
-          log('warn', `plan-to-prd: could not read plan file ${item.planFile} for ${item.id}: ${e.message}`);
+        if (planFileContent !== null) {
+          vars.plan_content = planFileContent;
+        } else {
+          if (planReadError) log('warn', `plan-to-prd: could not read plan file ${item.planFile} for ${item.id}: ${planReadError.message}`);
           vars.plan_content = item.description || '';
         }
         vars.plan_summary = (item.title || item.planFile).substring(0, 80);
         vars.plan_file = item.planFile || '';
         vars.project_name_lower = (targetProject?.name || 'project').toLowerCase();
+        vars.project_filename_slug = safePrdProjectSlug(targetProject?.name || 'project');
         // Default empty string so the {{existing_prd_json}} token always resolves —
         // playbook treats empty as "no existing PRD, fresh run". Without this default
         // the renderPlaybook pass logs an "unresolved template variables" warning
@@ -3805,8 +3937,9 @@ function discoverCentralWorkItems(config) {
         }
         if (!prdFilename) {
           // Generate unique PRD filename — check prd/ and prd/archive/ for collisions
-          const prdBase = vars.project_name_lower + '-' + dateStamp();
+          const prdBase = vars.project_filename_slug + '-' + dateStamp();
           prdFilename = prdBase + '.json';
+          shared.sanitizePath(prdFilename, PRD_DIR);
           const prdExisting = new Set([
             ...prdFiles,
             ...safeReadDir(path.join(PRD_DIR, 'archive')).filter(f => f.endsWith('.json')),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1806",
+  "version": "0.1.1808",
   "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/build-and-test.md

@@ -25,7 +25,7 @@ Work from the current checkout prepared by the engine. Read the repo's own instr
 
 If build or tests fail, report the relevant errors clearly and stop. Do not fix code, push commits, or create PRs from this task.
 
-If a server/app should be run for review, include the URL and a copy-pasteable run command with absolute paths. If the server must survive after the agent exits, start it detached and record the PID, restart command, and stop command; otherwise just provide the command for the user.
+If a server/app should be run for review, include the URL and a copy-pasteable run command with absolute paths. If the server must survive after the agent exits, follow the shared detached-process handoff rules: start it detached with stdio redirected to durable logs, smoke-check it, and record the PID/process identifier, log path, restart command, and stop command; otherwise just provide the command for the user.
 
 ## Findings
 
@@ -35,7 +35,7 @@ Include:
 - Branch, author, and project
 - Build status and important warnings/errors
 - Test status and failed test names if any
-- Local server status, URL, run command, PID, restart command, and stop command if applicable
+- Local server status, URL, run command, PID/process identifier, log path, restart command, and stop command if applicable
 - A short summary of whether the PR is ready to review
 
 ## Constraints

package/playbooks/plan-to-prd.md

@@ -14,6 +14,7 @@ A user has provided a plan. Analyze it against the codebase and produce a struct
 ## Instructions
 
 1. **Read the plan carefully** — understand the goals, scope, and requirements
+   - If the plan declares `Project: <name>` (including `**Project:** <name>`), the engine has resolved `{{project_name}}` from that declaration. Preserve `{{project_name}}` for the top-level `project`, default item `project`, filename, and implementation framing; do not let contextual mentions of another product or repository override it.
 2. **Check for an existing PRD** — if the engine provides `existing_prd_json` below, a PRD already exists for this plan. See "Reusing an Existing PRD" section for how to preserve item IDs and done statuses. If no existing PRD is provided, this is a fresh run — all items start as `"missing"`.
 3. **Explore the codebase** at `{{project_path}}` — understand the existing structure to write accurate descriptions and acceptance criteria. Do NOT use observations about existing PRs or partial work to set item statuses — status is determined only by existing PRD items (step 2), not codebase state
 4. **Break the plan into discrete, implementable items** — each should be a single PR's worth of work, with enough detail for another agent to implement it directly
@@ -47,7 +48,7 @@ This file is NOT checked into the repo. The engine reads it on every tick and di
       "id": "P-<uuid>",
       "name": "Short feature name",
       "description": "What needs to be built and why",
-      "project": "ProjectName",
+      "project": "{{project_name}}",
       "status": "missing",
       "estimated_complexity": "small|medium|large",
       "priority": "high|medium|low",
@@ -86,7 +87,7 @@ Rules for items:
 - IDs must be `P-<uuid>` format (e.g. `P-a3f9b2c1`) — globally unique, never sequential
 - **`status` is `"missing"` for new items** — do not set `done`, `complete`, `implemented`, or any other value based on codebase observations. The only exception is when reusing an existing PRD (see below) — items already `"done"` in the existing PRD carry forward as `"done"`. Pre-setting any other status on new items causes them to be silently skipped by the engine.
 - **Do NOT include a "verify" or "test" or "integration test" item** — the engine automatically creates a verify task when all PRD items are done. Adding one manually creates a duplicate that blocks plan completion.
-- **`project` field is REQUIRED** — set it to the project name where the code changes go (e.g., `"OfficeAgent"`, `"office-bohemia"`). Cross-repo plans must route each item to the correct project. The engine materializes items into that project's work queue.
+- **`project` field is REQUIRED** — set it to the project name where the code changes go (e.g., `"OfficeAgent"`, `"office-bohemia"`). If the plan declares a single project, every item must use `{{project_name}}`; contextual mentions of another repo/product must not override it. Cross-repo plans must route each item to the correct project. The engine materializes items into that project's work queue.
 - `depends_on` lists IDs of items that must be done first
 - Keep descriptions actionable — name the files, functions, patterns, or integration points the implementing agent should touch whenever the plan makes them clear
 - Include `acceptance_criteria` so reviewers know when it's done

package/playbooks/shared-rules.md

@@ -78,6 +78,13 @@ Use `status: "failed"` plus an accurate `failure_class`, `retryable`, and `needs
 
 Builds, dependency installs, tests, and local servers can be quiet for long periods. Run the repo's normal CLI commands and let them finish; do not add artificial progress output, heartbeat loops, or command-specific workarounds just to keep Minions active.
 
+For finite commands, keep them in the foreground and wait for completion. For persistent dev servers, emulators, file watchers, or other apps that must keep running after you exit, start them as an explicit detached handoff instead of an attached tool command:
+- Detach from the agent shell/session and redirect stdin/stdout/stderr to durable log files. Do not leave a background job inheriting the agent's stdio.
+- Use the OS-native detached process mechanism for the current platform, such as PowerShell `Start-Process -PassThru` on Windows or a POSIX `nohup`/`setsid` launch with `</dev/null` and `>log 2>&1 & echo $!` on macOS/Linux.
+- Capture the PID/process identifier, log path, URL or health-check target, restart command, and stop command with absolute paths.
+- Smoke-check that the URL/emulator/app is responsive before reporting success.
+- State clearly that the detached process is intentionally managed outside the agent/engine lifecycle and must be stopped with the recorded stop command.
+
 ## Done = pushed + local validation. Do NOT wait for remote pipelines.
 
 Your dispatch is **done** the moment (1) your fix is pushed to the branch and (2) any local validation you ran has finished. Write the completion JSON and exit immediately. **Do not** wait for the remote PR pipeline (Android OCM PR build, Espresso CloudTest, GitHub Actions, etc.) to finish before declaring done.

package/playbooks/templates/verify-guide.md

@@ -41,7 +41,9 @@ List anything that requires human judgment:
 ## Manual Testing Guide
 
 **How to run:** (server URL, emulator command, APK path, or N/A)
+**Detached PID / Log:** (PID and durable log path, or N/A)
 **Restart Command:** `cd <absolute-worktree-path> && <command>` (if applicable)
+**Stop Command:** (exact command to stop a detached process, or N/A)
 
 ### <Feature Name> (Plan Item ID)
 **What changed:** brief description

package/playbooks/test.md

@@ -31,18 +31,20 @@ If the task asks you to add or modify files, commit those focused changes, push
 
 If a build or test fails, report the error clearly instead of fixing it unless the task explicitly asks for a fix.
 
-If the task involves a local server or app, report the URL and a ready-to-paste run command with absolute paths:
+If the task involves a local server or app that does not need to stay running after you exit, report the URL and a ready-to-paste run command with absolute paths:
 
 ```text
 ## Run Command
 cd <absolute-path-to-project-or-worktree> && <exact command to start the server>
 ```
 
+If the server/app/emulator must stay running after you exit, follow the shared detached-process handoff rules: start it detached with stdio redirected to durable logs, smoke-check it, and report the PID/process identifier, log path, URL, restart command, and stop command.
+
 ## Findings
 
 Write findings to `{{team_root}}/notes/inbox/{{agent_id}}-{{item_id}}-{{date}}.md` only after successful completion.
 
-Include build status, test results, errors or warnings, run command, localhost URL if applicable, and PR URL if file changes were made.
+Include build status, test results, errors or warnings, run command, localhost URL if applicable, detached PID/log/restart/stop details if applicable, and PR URL if file changes were made.
 
 ## Constraints
 

package/playbooks/verify.md

@@ -25,7 +25,7 @@ Use the setup information in the plan details to create or enter the aggregate w
 
 For each relevant worktree, follow the repo's own instructions (`CLAUDE.md`, README, package files, Makefiles, project scripts), install/restore dependencies as needed, build, and run tests where they exist. If a project fails, report the error and continue verifying the rest; do not turn this into an implementation/fix task.
 
-If there is a user-facing app, identify the normal command and URL. If the app needs to keep running after the agent exits, start it detached in the worktree, save the PID, verify the URL responds, and include restart/stop commands with absolute paths.
+If there is a user-facing app, identify the normal command and URL. If the app needs to keep running after the agent exits, follow the shared detached-process handoff rules: start it detached in the worktree with stdio redirected to durable logs, save the PID/process identifier and log path, verify the URL responds, and include restart/stop commands with absolute paths.
 
 ## Testing Guide