@yemi33/minions 0.1.2379 → 0.1.2381

package/engine/metrics-store.js

@@ -1,6 +1,6 @@
-// engine/metrics-store.js — SQL-backed implementation of engine/metrics.json.
+// engine/metrics-store.js — SQL-backed engine metrics.
 //
-// metrics.json is a single flat object whose top-level keys mix
+// Metrics expose a flat object whose top-level keys mix
 // per-agent counters with reserved keys (`_engine`, `_daily`,
 // `_contextPressure`). The store reconstructs that legacy shape for
 // reads, and reverses it for writes — each (kind, key) row holds one

package/engine/note-link-backfill.js

@@ -148,12 +148,7 @@ function repointItemNoteLinks(item, resolve) {
   return fixed;
 }
 
-// Repair broken note links across every work-items file (each project's plus
-// the central one), routed through shared.mutateWorkItems so the canonical SQL
-// store AND its JSON mirror stay consistent — the same write path the live
-// rewriter uses. Idempotent: only touches links that are provably broken AND
-// resolvable, so once healed a re-run writes nothing (skipWriteIfUnchanged).
-// Safe to call on every engine boot. Per-file try/catch isolates a bad scope.
+// Repair broken note links across every project scope plus central.
 function runNoteLinkBackfill(opts = {}) {
   const shared = require('./shared');
   const minionsDir = opts.minionsDir || shared.MINIONS_DIR;
@@ -172,14 +167,14 @@ function runNoteLinkBackfill(opts = {}) {
   const projects = Array.isArray(config.projects) ? config.projects : [];
   const candidates = [];
   for (const p of projects) {
-    if (p && p.name) candidates.push(path.join(minionsDir, 'projects', p.name, 'work-items.json'));
+    if (p && p.name) candidates.push(p);
   }
-  candidates.push(path.join(minionsDir, 'work-items.json'));
+  candidates.push('central');
 
   let scanned = 0, fixedItems = 0, fixedLinks = 0;
-  for (const wiPath of candidates) {
+  for (const scope of candidates) {
     try {
-      shared.mutateWorkItems(wiPath, (items) => {
+      shared.mutateWorkItems(scope, (items) => {
         if (!Array.isArray(items)) return items;
         for (const item of items) {
           if (!item) continue;
@@ -191,7 +186,7 @@ function runNoteLinkBackfill(opts = {}) {
         }
         return items;
       });
-    } catch { /* per-file isolation — one bad scope can't block the others */ }
+    } catch { /* one bad scope cannot block the others */ }
   }
 
   return { scanned, fixedItems, fixedLinks };

package/engine/pipeline.js

@@ -8,20 +8,18 @@ const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
-const { safeJson, safeJsonObj, safeJsonArr, safeJsonNoRestore, safeWrite, safeRead, safeReadDir, uid, log, ts, dateStamp, mutateJsonFileLocked, mutateWorkItems, mutatePipelineRuns, slugify, formatTranscriptEntry, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, READ_ONLY_ROOT_TASK_TYPES, ENGINE_DEFAULTS, MINIONS_DIR, isPrdArchived } = shared;
+const { safeJson, safeJsonArr, safeJsonNoRestore, safeWrite, safeRead, safeReadDir, uid, log, ts, dateStamp, mutateJsonFileLocked, mutateWorkItems, mutatePipelineRuns, slugify, formatTranscriptEntry, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, READ_ONLY_ROOT_TASK_TYPES, ENGINE_DEFAULTS, MINIONS_DIR, isPrdArchived } = shared;
 const routing = require('./routing');
 const http = require('http');
 const { shouldRunNow } = require('./scheduler');
+const smallStateStore = require('./small-state-store');
 
 // All module-relative paths flow through MINIONS_DIR so MINIONS_TEST_DIR
 // (set by test/unit.test.js createTestMinionsDir) consistently redirects
 // pipeline writes into the temp root instead of the live runtime root.
 const PIPELINES_DIR = path.join(MINIONS_DIR, 'pipelines');
-const PIPELINE_RUNS_PATH = path.join(MINIONS_DIR, 'engine', 'pipeline-runs.json');
-const CENTRAL_WI_PATH = path.join(MINIONS_DIR, 'work-items.json');
 const MEETINGS_DIR = path.join(MINIONS_DIR, 'meetings');
 const PLANS_DIR = path.join(MINIONS_DIR, 'plans');
-const PRD_DIR = path.join(MINIONS_DIR, 'prd');
 const NOTES_INBOX_DIR = path.join(MINIONS_DIR, 'notes', 'inbox');
 const NOTES_ARCHIVE_DIR = path.join(MINIONS_DIR, 'notes', 'archive');
 const CONFIG_PATH = path.join(MINIONS_DIR, 'config.json');
@@ -74,22 +72,11 @@ function deletePipeline(id) {
 // ── Run State ────────────────────────────────────────────────────────────────
 
 function getPipelineRuns() {
-  return safeJsonObj(PIPELINE_RUNS_PATH);
+  return smallStateStore.readPipelineRuns();
 }
 
-// W-mrcrh5hj0017d22f: SQL is the canonical (and only) work-items store post
-// Phase 9.4 — the JSON files (central work-items.json + each
-// projects/<name>/work-items.json) are passive, best-effort mirrors that can
-// legitimately lag behind a just-completed write (mirror failures are
-// swallowed by design so they never block the SQL write; see
-// work-items-store.js's `_mirrorJsonFromSql` comments). Reading those JSON
-// files directly (via safeJson/safeJsonArr) can therefore observe a work
-// item whose `status` mirrored to DONE but whose `resultSummary` write
-// hasn't landed in the mirror yet — which silently degraded stage-output
-// template substitution ({{stages.<id>.output}}) to the stage's own work
-// item id instead of its real completion text. Route every work-item read
-// in this module through the SQL-backed store so pipeline state always sees
-// the authoritative record.
+// Always read work items from the authoritative SQL store so stage-output
+// template substitution sees the latest completion metadata.
 function _allWorkItems() {
   return require('./work-items-store').readAllWorkItems();
 }
@@ -319,8 +306,8 @@ function _pipelineProjectSlug(project) {
   return project ? shared.safeSlugComponent(project.name || 'project', 32).toLowerCase() : 'central';
 }
 
-function _pipelineWorkItemsPath(project) {
-  return project ? shared.projectWorkItemsPath(project) : CENTRAL_WI_PATH;
+function _pipelineWorkItemScope(project) {
+  return project || 'central';
 }
 
 // ── Condition Evaluation ─────────────────────────────────────────────────────
@@ -435,7 +422,7 @@ function executeTaskStage(stage, stageState, run, config, pipeline = {}) {
     for (const project of projectResolution.projects) {
       const projectSlug = _pipelineProjectSlug(project);
       const id = `PL-${run.runId.slice(4, 12)}-${stage.id}-${i}${projectResolution.projects.length > 1 || project ? '-' + projectSlug : ''}`;
-      const wiPath = _pipelineWorkItemsPath(project);
+      const wiScope = _pipelineWorkItemScope(project);
       const wiType = routing.normalizeWorkType(item.type || stage.taskType, WORK_TYPE.EXPLORE);
       // W-mp8ho6w500034a58: read-only stages don't commit, so a pipeline
       // branch label is meaningless to them — omit it entirely so the
@@ -443,7 +430,7 @@ function executeTaskStage(stage, stageState, run, config, pipeline = {}) {
       const wiBranch = READ_ONLY_ROOT_TASK_TYPES.has(wiType)
         ? null
         : `pipeline/${run.pipelineId}/${stage.id}`;
-      mutateWorkItems(wiPath, workItems => {
+      mutateWorkItems(wiScope, workItems => {
         if (workItems.some(w => w.id === id)) { createdIds.push(id); return workItems; }
         workItems.push({
           id,
@@ -574,12 +561,10 @@ const _VALID_EXISTING_PRD_STATUSES = new Set(Object.values(PLAN_STATUS));
 // permanently skip re-running plan-to-prd for a plan that never actually got
 // a usable PRD. Require both a recognized top-level status AND an array
 // `missing_features` field before counting the PRD as an existing conversion.
-function _findExistingPrdForPlan(planFile, prdDir) {
+function _findExistingPrdForPlan(planFile) {
   const prdFiles = require('./prd-store').listPrdRows().filter(row => !row.archived);
   const planKey = _canonicalPlanName(planFile);
   for (const { filename: pf, plan: prd } of prdFiles) {
-    // safeJsonNoRestore: PRDs are terminal artifacts — never restore archived
-    // PRDs from a stale .backup sidecar (W-mouptdh1000h9f39).
     if (!prd?.source_plan || _canonicalPlanName(path.basename(String(prd.source_plan))) !== planKey) continue;
     if (!(_VALID_EXISTING_PRD_STATUSES.has(prd.status) || isPrdArchived(prd)) || !Array.isArray(prd.missing_features)) {
       log('warn', `Pipeline plan-to-prd: found PRD "${pf}" for plan "${planFile}" but it lacks a valid status/missing_features (garbage/incomplete conversion) — treating plan-to-prd as not yet done`);
@@ -623,8 +608,7 @@ async function executePlanStage(stage, stageState, run, config, pipeline = {}) {
       log('info', `Pipeline ${run.pipelineId}: reconciling plan stage — adopting existing plan "${existingPlanFile}"`);
 
       // Check if a PRD already exists for this plan (skip plan-to-prd entirely)
-      const prdDir = PRD_DIR;
-      const existingPrdFile = _findExistingPrdForPlan(existingPlanFile, prdDir);
+      const existingPrdFile = _findExistingPrdForPlan(existingPlanFile);
       if (existingPrdFile) {
         log('info', `Pipeline ${run.pipelineId}: PRD "${existingPrdFile}" already exists for plan "${existingPlanFile}" — skipping plan-to-prd`);
         return {
@@ -636,10 +620,10 @@ async function executePlanStage(stage, stageState, run, config, pipeline = {}) {
       // Adopt or create plan-to-prd WIs atomically under lock for each target project.
       const adoptedWiIds = [];
       for (const project of targetProjects) {
-        const wiPath = _pipelineWorkItemsPath(project);
+        const wiScope = _pipelineWorkItemScope(project);
         const wiId = wiIdForProject(project);
         let adoptedWiId = wiId;
-        mutateWorkItems(wiPath, workItems => {
+        mutateWorkItems(wiScope, workItems => {
           const existing = workItems.find(w => w.type === WORK_TYPE.PLAN_TO_PRD && w.planFile === existingPlanFile);
           if (existing) {
             existing._pipelineRun = run.runId;
@@ -744,9 +728,9 @@ async function executePlanStage(stage, stageState, run, config, pipeline = {}) {
 
   const createdWiIds = [];
   for (const project of targetProjects) {
-    const wiPath = _pipelineWorkItemsPath(project);
+    const wiScope = _pipelineWorkItemScope(project);
     const wiId = wiIdForProject(project);
-    mutateWorkItems(wiPath, workItems => {
+    mutateWorkItems(wiScope, workItems => {
       if (!workItems.some(w => w.id === wiId)) {
         workItems.push({
           id: wiId,
@@ -986,7 +970,6 @@ function isStageComplete(stage, stageState, run, config) {
       if (!prdDone) return false;
 
       // Discover PRDs and their work items — collect into local arrays, then merge into artifacts
-      const prdDir = PRD_DIR;
       const plans = artifacts.plans || [];
       const discoveredPrds = [];
       const discoveredWiIds = [];
@@ -1019,9 +1002,8 @@ function isStageComplete(stage, stageState, run, config) {
       // Auto-approve if configured
       if (stage.autoApprove && artifacts.prds?.length > 0) {
         for (const prdFile of artifacts.prds) {
-          const prdPath = path.join(prdDir, prdFile);
           let approved = false;
-          mutateJsonFileLocked(prdPath, (prd) => {
+          require('./prd-store').mutatePrd(prdFile, (prd) => {
             if (prd && prd.status === PLAN_STATUS.AWAITING_APPROVAL) {
               prd.status = PLAN_STATUS.APPROVED;
               prd.approvedAt = ts();
@@ -1029,7 +1011,7 @@ function isStageComplete(stage, stageState, run, config) {
               approved = true;
             }
             return prd;
-          }, { skipWriteIfUnchanged: true });
+          });
           if (approved) log('info', `Pipeline ${run.pipelineId}: auto-approved PRD ${prdFile}`);
         }
       }
@@ -1047,7 +1029,7 @@ function isStageComplete(stage, stageState, run, config) {
       if (prIds.length === 0) return true; // nothing to merge
       const projects = shared.getProjects(config);
       for (const project of projects) {
-        const prs = safeJsonArr(shared.projectPrPath(project));
+        const prs = shared.readPullRequests(project);
         for (const prId of prIds) {
           const pr = shared.findPrRecord(prs, prId, project);
           if (pr && pr.status !== PR_STATUS.MERGED && pr.status !== PR_STATUS.ABANDONED) return false;

package/engine/playbook.js

@@ -402,6 +402,7 @@ const PLAYBOOK_REQUIRED_VARS = {
   'implement':            ['item_id', 'item_name', 'branch_name', 'project_path'],
   'implement-shared':     ['item_id', 'item_name', 'branch_name', 'worktree_path'],
   'fix':                  ['pr_id', 'pr_branch'],
+  // M005 — SHERLOC two-phase build-fix. Same PR context as fix.
   'build-fix-complex':    ['pr_id', 'pr_branch'],
   'review':               ['pr_id', 'pr_branch'],
   'build-and-test':       ['pr_id', 'pr_branch', 'project_path'],
@@ -434,11 +435,14 @@ const PLAYBOOK_REQUIRED_VARS = {
   'meeting-investigate':  ['meeting_title', 'agenda'],
   'meeting-debate':       ['meeting_title', 'agenda'],
   'meeting-conclude':     ['meeting_title', 'agenda'],
-  // M005 — SHERLOC two-phase build-fix. Same required vars as fix (PR-context
-  // dispatch), but routed to build-fix-complex.md for multi-file failures.
-  'build-fix-complex':    ['pr_id', 'pr_branch'],
 };
 
+const LIVE_VALIDATION_DEFERRED_PLAYBOOKS = new Set([
+  'implement',
+  'fix',
+  'build-fix-complex',
+]);
+
 /**
  * Validate that all required template variables for a playbook type are present
  * and non-empty in the provided vars object.
@@ -848,18 +852,11 @@ function renderPlaybook(type, vars) {
     } catch (e) { log('warn', `qa-validate context render failed: ${e.message}`); }
   }
 
-  // M005 — live-validation deferred-build notice.
-  // Inject only for coding playbooks (implement, fix, docs, decompose) when the
-  // matched project has liveValidation.autoDispatch === true. Agents on these
-  // projects must push code without running builds or tests; a separate dispatch
-  // (of liveValidation.type) runs the full build on the live environment after
-  // the PR lands. When autoDispatch is false the agent is responsible for its own
-  // inline validation (may fail in isolated worktrees — documented limitation).
-  const LIVE_VALIDATION_PLAYBOOKS = new Set(['implement', 'fix', 'build-fix-complex', 'docs', 'decompose']);
-  if (LIVE_VALIDATION_PLAYBOOKS.has(type)) {
-    const lv = matchedProject && matchedProject.liveValidation;
-    if (lv && lv.autoDispatch === true) {
-      const lvType = lv.type || 'live-validation';
+  // Only playbooks whose completion creates the lifecycle follow-up may defer
+  // builds. The shared resolver also requires effective live `test` routing.
+  if (LIVE_VALIDATION_DEFERRED_PLAYBOOKS.has(type)) {
+    const lvType = shared.resolveLiveValidationAutoDispatchType(matchedProject);
+    if (lvType) {
       inertAppendices.push(
         `\n\n---\n\n## Live Validation — Validation Deferred\n\n` +
         `**Live validation is deferred for this project.** ` +
@@ -1077,7 +1074,7 @@ function buildSystemPrompt(agentId, config, project) {
   prompt += `2. ${getRepoHostToolRule(project)}\n`;
   prompt += `3. Follow the project conventions in CLAUDE.md if present\n`;
   prompt += `4. Write learnings to the path specified in the task prompt (format: \`notes/inbox/{agent}-{work-item-id}-{date}-{time}.md\`)\n`;
-  prompt += `5. Agent status is managed by the engine via dispatch.json — agents do not need to track their own status\n\n`;
+  prompt += `5. Agent status is managed by the engine — agents do not need to track their own status\n\n`;
 
   // The lean system prompt (identity + rules) does not contain task-dispatch
   // sections (## Your Task, ## Tools, ## Constraints) by design — those live

package/engine/prd-store.js

@@ -1,9 +1,6 @@
 // engine/prd-store.js
 //
-// SQL-authoritative PRD state. Paths are retained as stable identifiers for
-// existing callers, but no runtime PRD JSON is read or written here.
-
-const path = require('path');
+// SQL-authoritative PRD state.
 
 function _toMs(v) {
   if (v == null) return null;
@@ -13,28 +10,12 @@ function _toMs(v) {
 }
 function _bool01(v) { return v ? 1 : 0; }
 
-// Resolve <MINIONS_DIR>/prd/<f>.json → {filename, archived:0}; the
-// prd/archive/<f>.json variant → {filename, archived:1}; anything else → null.
-// Path comparison is normalized + case-insensitive on the directory prefix so
-// Windows drive-letter / separator differences don't cause a miss.
-function parsePrdPath(filePath) {
-  if (!filePath || typeof filePath !== 'string') return null;
-  let minionsDir;
-  try { minionsDir = require('./shared').MINIONS_DIR; } catch { return null; }
-  if (!minionsDir) return null;
-  const norm = (p) => path.resolve(p).replace(/\\/g, '/').toLowerCase();
-  const full = norm(filePath);
-  const prdRoot = norm(path.join(minionsDir, 'prd'));
-  const archiveRoot = norm(path.join(minionsDir, 'prd', 'archive'));
-  if (!full.endsWith('.json')) return null;
-  const base = path.basename(filePath);
-  if (full === norm(path.join(archiveRoot, base)) && full.startsWith(archiveRoot + '/')) {
-    return { filename: base, archived: 1 };
-  }
-  if (full === norm(path.join(prdRoot, base)) && full.startsWith(prdRoot + '/')) {
-    return { filename: base, archived: 0 };
+function _validatePrdFilename(filename) {
+  if (typeof filename !== 'string' || !filename.endsWith('.json')
+      || filename.includes('/') || filename.includes('\\') || filename === '.json') {
+    throw new TypeError('PRD filename must be a basename ending in .json');
   }
-  return null;
+  return filename;
 }
 
 // (filename, archived) → plans.id, preferring the same archived bucket.
@@ -48,6 +29,22 @@ function _resolvePlanId(db, sourcePlan, archived) {
 
 // Core upsert: write/replace the prds row + its prd_items + prd_verify_prs for
 // (filename, archived). Returns the prds.id. Runs inside a transaction.
+function _clearWorkItemLinks(db, prdId, predicate = '', params = []) {
+  db.prepare(`
+    UPDATE work_items SET prd_item_id=NULL
+    WHERE prd_item_id IN (
+      SELECT id FROM prd_items WHERE prd_id=? ${predicate}
+    )
+  `).run(prdId, ...params);
+}
+
+function _deletePrdRow(db, prdId) {
+  _clearWorkItemLinks(db, prdId);
+  db.prepare('DELETE FROM prd_items WHERE prd_id=?').run(prdId);
+  db.prepare('DELETE FROM prd_verify_prs WHERE prd_id=?').run(prdId);
+  db.prepare('DELETE FROM prds WHERE id=?').run(prdId);
+}
+
 function _upsertPrd(db, filename, archived, prd, now) {
   const sourcePlan = prd.source_plan || prd.sourcePlan || null;
   const planId = _resolvePlanId(db, sourcePlan, archived);
@@ -98,10 +95,13 @@ function _upsertPrd(db, filename, archived, prd, now) {
   for (const ft of features) { if (ft && typeof ft === 'object' && ft.id) keepIds.push(String(ft.id)); }
   // Drop id-bearing items no longer on the PRD, plus all NULL-feature_id rows.
   if (keepIds.length) {
+    const predicate = `AND feature_id IS NOT NULL AND feature_id NOT IN (${keepIds.map(() => '?').join(',')})`;
+    _clearWorkItemLinks(db, prdId, predicate, keepIds);
     db.prepare(
       `DELETE FROM prd_items WHERE prd_id=? AND feature_id IS NOT NULL AND feature_id NOT IN (${keepIds.map(() => '?').join(',')})`
     ).run(prdId, ...keepIds);
   } else {
+    _clearWorkItemLinks(db, prdId, 'AND feature_id IS NOT NULL');
     db.prepare('DELETE FROM prd_items WHERE prd_id=? AND feature_id IS NOT NULL').run(prdId);
   }
   db.prepare('DELETE FROM prd_items WHERE prd_id=? AND feature_id IS NULL').run(prdId);
@@ -181,27 +181,51 @@ function _upsertPrd(db, filename, archived, prd, now) {
   return prdId;
 }
 
-function writePrd(filePath, prd) {
-  const parsed = parsePrdPath(filePath);
-  if (!parsed || !prd || typeof prd !== 'object' || Array.isArray(prd)) {
-    throw new TypeError('prd-store.writePrd requires a PRD path and object');
+function writePrd(filename, prd, { archived = false } = {}) {
+  _validatePrdFilename(filename);
+  if (!prd || typeof prd !== 'object' || Array.isArray(prd)) {
+    throw new TypeError('prd-store.writePrd requires a filename and object');
   }
   const { getDb, withTransaction } = require('./db');
   const db = getDb();
-  const prdId = withTransaction(db, () => _upsertPrd(db, parsed.filename, parsed.archived, prd, Date.now()));
-  require('./db-events').emitStateEvent('prds', { filename: parsed.filename, archived: parsed.archived });
+  const archivedValue = archived ? 1 : 0;
+  const prdId = withTransaction(db, () => _upsertPrd(db, filename, archivedValue, prd, Date.now()));
+  require('./db-events').emitStateEvent('prds', { filename, archived: archivedValue });
   return { ok: true, id: prdId, plan: prd };
 }
 
-function mutatePrd(filePath, mutator, { defaultValue = {} } = {}) {
-  const parsed = parsePrdPath(filePath);
-  if (!parsed || typeof mutator !== 'function') {
-    throw new TypeError('prd-store.mutatePrd requires a PRD path and mutator');
+function createPrdUnique(baseFilename, prd) {
+  _validatePrdFilename(baseFilename);
+  if (!prd || typeof prd !== 'object' || Array.isArray(prd)) {
+    throw new TypeError('prd-store.createPrdUnique requires a PRD object');
+  }
+  const stem = baseFilename.slice(0, -'.json'.length);
+  const { getDb, withTransaction } = require('./db');
+  const db = getDb();
+  const filename = withTransaction(db, () => {
+    const exists = db.prepare('SELECT 1 FROM prds WHERE filename=? LIMIT 1');
+    for (let attempt = 0; attempt < 100; attempt++) {
+      const candidate = attempt === 0 ? baseFilename : `${stem}-${attempt}.json`;
+      if (exists.get(candidate)) continue;
+      _upsertPrd(db, candidate, 0, prd, Date.now());
+      return candidate;
+    }
+    throw new Error('Could not reserve unique PRD filename after 100 attempts');
+  });
+  require('./db-events').emitStateEvent('prds', { filename, archived: 0 });
+  return filename;
+}
+
+function mutatePrd(filename, mutator, { archived = false, defaultValue = {} } = {}) {
+  _validatePrdFilename(filename);
+  if (typeof mutator !== 'function') {
+    throw new TypeError('prd-store.mutatePrd requires a filename and mutator');
   }
   const { getDb, withTransaction } = require('./db');
   const db = getDb();
   const result = withTransaction(db, () => {
-    const row = db.prepare('SELECT data FROM prds WHERE filename=? AND archived=?').get(parsed.filename, parsed.archived);
+    const archivedValue = archived ? 1 : 0;
+    const row = db.prepare('SELECT data FROM prds WHERE filename=? AND archived=?').get(filename, archivedValue);
     let current = row ? JSON.parse(row.data) : structuredClone(defaultValue);
     if (!current || typeof current !== 'object' || Array.isArray(current)) current = structuredClone(defaultValue);
     const next = mutator(current);
@@ -209,36 +233,33 @@ function mutatePrd(filePath, mutator, { defaultValue = {} } = {}) {
     if (!finalData || typeof finalData !== 'object' || Array.isArray(finalData)) {
       throw new TypeError('PRD mutator must return an object or mutate in place');
     }
-    _upsertPrd(db, parsed.filename, parsed.archived, finalData, Date.now());
+    _upsertPrd(db, filename, archivedValue, finalData, Date.now());
     return finalData;
   });
-  require('./db-events').emitStateEvent('prds', { filename: parsed.filename, archived: parsed.archived });
+  require('./db-events').emitStateEvent('prds', { filename, archived: archived ? 1 : 0 });
   return result;
 }
 
-function deletePrd(filePath) {
-  const parsed = parsePrdPath(filePath);
-  if (!parsed) throw new TypeError('prd-store.deletePrd requires a PRD path');
+function deletePrd(filename, { archived = false } = {}) {
+  _validatePrdFilename(filename);
   const { getDb, withTransaction } = require('./db');
   const db = getDb();
   const removed = withTransaction(db, () => {
-    const row = db.prepare('SELECT id FROM prds WHERE filename=? AND archived=?').get(parsed.filename, parsed.archived);
+    const archivedValue = archived ? 1 : 0;
+    const row = db.prepare('SELECT id FROM prds WHERE filename=? AND archived=?').get(filename, archivedValue);
     if (!row) return false;
-    db.prepare('DELETE FROM prd_items WHERE prd_id=?').run(row.id);
-    db.prepare('DELETE FROM prd_verify_prs WHERE prd_id=?').run(row.id);
-    db.prepare('DELETE FROM prds WHERE id=?').run(row.id);
+    _deletePrdRow(db, row.id);
     return true;
   });
-  if (removed) require('./db-events').emitStateEvent('prds', { filename: parsed.filename, archived: parsed.archived, removed: true });
+  if (removed) require('./db-events').emitStateEvent('prds', { filename, archived: archived ? 1 : 0, removed: true });
   return removed;
 }
 
-function readPrd(filePath) {
-  const parsed = parsePrdPath(filePath);
-  if (!parsed) return null;
+function readPrd(filename, { archived = false } = {}) {
+  _validatePrdFilename(filename);
   const row = require('./db').getDb()
     .prepare('SELECT data FROM prds WHERE filename=? AND archived=?')
-    .get(parsed.filename, parsed.archived);
+    .get(filename, archived ? 1 : 0);
   return row ? JSON.parse(row.data) : null;
 }
 
@@ -262,9 +283,7 @@ function restorePrdFromArchive(filename) {
     if (!row) return null;
     const prd = JSON.parse(row.data);
     _upsertPrd(db, filename, 0, prd, Date.now());
-    db.prepare('DELETE FROM prd_items WHERE prd_id=?').run(row.id);
-    db.prepare('DELETE FROM prd_verify_prs WHERE prd_id=?').run(row.id);
-    db.prepare('DELETE FROM prds WHERE id=?').run(row.id);
+    _deletePrdRow(db, row.id);
     return prd;
   });
   if (restored) {
@@ -332,8 +351,8 @@ function listPrdRows() {
 }
 
 module.exports = {
-  parsePrdPath,
   writePrd,
+  createPrdUnique,
   mutatePrd,
   deletePrd,
   readPrd,

package/engine/preflight.js

@@ -266,11 +266,8 @@ function runPreflight(opts = {}) {
     // discoverFromWorkItems / discoverFromPrs return [] without logging.
     try {
       const projectWarns = shared.projectWorkSourceWarnings(opts.config, (project) => {
-        const wiPath = shared.projectWorkItemsPath(project);
-        const prPath = shared.projectPrPath(project);
-        const safeJson = shared.safeJson;
-        const wi = (() => { try { const a = safeJson(wiPath); return Array.isArray(a) ? a.length : 0; } catch { return 0; } })();
-        const pr = (() => { try { const a = safeJson(prPath); return Array.isArray(a) ? a.length : 0; } catch { return 0; } })();
+        const wi = (() => { try { return shared.readWorkItems(project).length; } catch { return 0; } })();
+        const pr = (() => { try { return shared.readPullRequests(project).length; } catch { return 0; } })();
         return { workItems: wi, pullRequests: pr };
       });
       for (const w of projectWarns) {