@magnusekdahl/parallix 1.1.0 → 1.2.0

package/lib/tools/backlog.js

@@ -5,48 +5,63 @@ const { WORKFLOW_AGENT_NAMES } = require('../agents/agents');
 const fmt = require('../core/fmt');
 const { resolveTaskStorage } = require('../core/product-config');
 
+/** @returns {readonly string[]} */
 function getSupportedAgents() {
   return WORKFLOW_AGENT_NAMES;
 }
 
+/** @param {string} [rootDir] @returns {{tasksDir: string, completedDir: string, archiveTasksDir: string}} */
 function getTaskStorage(rootDir = process.cwd()) {
   return resolveTaskStorage(rootDir);
 }
 
+/**
+ * @param {string} slug
+ * @param {string} [rootDir]
+ * @returns {string[]}
+ */
 function findTaskFiles(slug, rootDir = process.cwd()) {
   const { tasksDir, completedDir, archiveTasksDir: archivedDir } = getTaskStorage(rootDir);
-  const sortByBacklogState = (filePath) => {
-    if (filePath.startsWith(tasksDir + path.sep)) return 0;
-    if (filePath.startsWith(completedDir + path.sep)) return 1;
-    if (filePath.startsWith(archivedDir + path.sep)) return 2;
+  const sortByBacklogState = /** @param {string} filePath */ (filePath) => {
+    if (filePath.startsWith(tasksDir + path.sep)) {return 0;}
+    if (filePath.startsWith(completedDir + path.sep)) {return 1;}
+    if (filePath.startsWith(archivedDir + path.sep)) {return 2;}
     return 3;
   };
 
+  /** @param {string} dir */
   const scan = (dir) => {
-    if (!fs.existsSync(dir)) return [];
+    if (!fs.existsSync(dir)) {return [];}
     const files = fs.readdirSync(dir);
     const normalizedSlug = slug.toLowerCase();
     return files
-      .filter(f => f.toLowerCase().startsWith(normalizedSlug))
-      .map(f => path.join(dir, f));
+      .filter(/** @param {string} f */ f => f.toLowerCase().startsWith(normalizedSlug))
+      .map(/** @param {string} f */ f => path.join(dir, f));
   };
 
   const matches = [...scan(tasksDir), ...scan(completedDir), ...scan(archivedDir)];
   return matches.sort((a, b) => sortByBacklogState(a) - sortByBacklogState(b) || a.localeCompare(b));
 }
 
+/**
+ * @param {string} slug
+ * @param {string} [rootDir]
+ * @returns {{ok: boolean, taskFile?: string, matches: string[], reason?: string}}
+ */
 function resolveTaskFile(slug, rootDir = process.cwd()) {
   let matches = findTaskFiles(slug, rootDir);
   const normalizedId = slug.toUpperCase();
   const { tasksDir, completedDir, archiveTasksDir: archivedDir } = getTaskStorage(rootDir);
+  /** @param {string[]} candidateMatches */
   const preferSameTaskInHigherPriorityDir = (candidateMatches) => {
-    if (candidateMatches.length < 2) return null;
+    if (candidateMatches.length < 2) {return null;}
     const [preferred, ...rest] = candidateMatches;
-    return rest.every(match => path.basename(match) === path.basename(preferred)) ? preferred : null;
+    return rest.every(/** @param {string} match */ match => path.basename(match) === path.basename(preferred)) ? preferred : null;
   };
 
+  /** @param {string[]} candidateFiles @param {string} targetId */
   const findById = (candidateFiles, targetId) => {
-    return candidateFiles.filter(f => {
+    return candidateFiles.filter(/** @param {string} f */ f => {
       try {
         const content = fs.readFileSync(f, 'utf8');
         const idMatch = content.match(/^id:\s*([^\r\n]+)/m);
@@ -115,13 +130,23 @@ function resolveTaskFile(slug, rootDir = process.cwd()) {
   return { ok: false, reason: 'ambiguous', matches };
 }
 
+/**
+ * @param {string} slug
+ * @param {string} [rootDir]
+ * @returns {string|undefined|null}
+ */
 function findTaskFile(slug, rootDir = process.cwd()) {
   const result = resolveTaskFile(slug, rootDir);
   return result.ok ? result.taskFile : null;
 }
 
+/**
+ * @param {{ok: boolean, taskFile?: string, matches: string[], reason?: string}} result
+ * @param {string} slug
+ * @param {Function} [log]
+ */
 function reportTaskResolution(result, slug, log = fmt.log.plain) {
-  if (result.ok) return;
+  if (result.ok) {return;}
   const { tasksDir, completedDir } = getTaskStorage(process.cwd());
   const taskHint = path.relative(process.cwd(), tasksDir).split(path.sep).join('/');
   const completedHint = path.relative(process.cwd(), completedDir).split(path.sep).join('/');
@@ -139,13 +164,19 @@ function reportTaskResolution(result, slug, log = fmt.log.plain) {
   }
 }
 
+/** @param {string} file @returns {string|null} */
 function taskIdFromFilename(file) {
   // Extract ID from filename prefix (e.g., task-093 or task-093.01)
   const filenameMatch = file.match(/^(task-\d+(?:\.\d+)?)/i);
   return filenameMatch ? filenameMatch[1].toUpperCase() : null;
 }
 
-function checkBacklogIntegrity(rootDir = process.cwd(), slug = null) {
+/**
+ * @param {string} [rootDir]
+ * @param {string} [slug]
+ * @returns {{file: string, type: string, taskId?: string, canonicalFile?: string}[]}
+ */
+function checkBacklogIntegrity(rootDir = process.cwd(), /** @type {string|null} */ slug = null) {
   const { tasksDir, completedDir, archiveTasksDir: archivedDir } = getTaskStorage(rootDir);
   const issues = [];
   const normalizedSlug = slug ? slug.toLowerCase() : null;
@@ -157,20 +188,21 @@ function checkBacklogIntegrity(rootDir = process.cwd(), slug = null) {
   const tasksLocations = new Map();      // id -> rel path in tasks/
   const canonicalLocations = new Map();  // id -> rel path in completed|archive
 
+  /** @param {string} dir @param {{canonical?: boolean}} [opts] */
   const scan = (dir, { canonical = false } = {}) => {
-    if (!fs.existsSync(dir)) return;
-    const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+    if (!fs.existsSync(dir)) {return;}
+    const files = fs.readdirSync(dir).filter(/** @param {string} f */ f => f.endsWith('.md'));
     for (const file of files) {
       if (normalizedSlug && !file.toLowerCase().startsWith(normalizedSlug)) {
         continue;
       }
       const filePath = path.join(dir, file);
       const filenameId = taskIdFromFilename(file);
-      if (!filenameId) continue;
+      if (!filenameId) {continue;}
       const relPath = path.relative(rootDir, filePath);
 
       if (canonical) {
-        if (!canonicalLocations.has(filenameId)) canonicalLocations.set(filenameId, relPath);
+        if (!canonicalLocations.has(filenameId)) {canonicalLocations.set(filenameId, relPath);}
       } else if (!tasksLocations.has(filenameId)) {
         tasksLocations.set(filenameId, relPath);
       }
@@ -243,8 +275,9 @@ function pruneStaleBacklogDuplicates(rootDir = process.cwd()) {
   return removed;
 }
 
+/** @param {string} taskFilePath @returns {string|null} */
 function getTaskStatus(taskFilePath) {
-  if (!taskFilePath || !fs.existsSync(taskFilePath)) return null;
+  if (!taskFilePath || !fs.existsSync(taskFilePath)) {return null;}
   const content = fs.readFileSync(taskFilePath, 'utf8');
 
   // Try YAML first
@@ -262,8 +295,9 @@ function getTaskStatus(taskFilePath) {
   return null;
 }
 
+/** @param {string} taskFilePath @param {string} newStatus @returns {boolean} */
 function setTaskStatus(taskFilePath, newStatus) {
-  if (!taskFilePath || !fs.existsSync(taskFilePath)) return false;
+  if (!taskFilePath || !fs.existsSync(taskFilePath)) {return false;}
   let content = fs.readFileSync(taskFilePath, 'utf8');
 
   // Update YAML
@@ -287,11 +321,16 @@ function setTaskStatus(taskFilePath, newStatus) {
   return true;
 }
 
+/**
+ * @param {string} slug
+ * @param {string} [rootDir]
+ * @returns {boolean}
+ */
 function completeTask(slug, rootDir = process.cwd()) {
   const resolution = resolveTaskFile(slug, rootDir);
-  if (!resolution.ok) return false;
+  if (!resolution.ok) {return false;}
 
-  const taskFilePath = resolution.taskFile;
+  const taskFilePath = /** @type {string} */ (resolution.taskFile);
   const fileName = path.basename(taskFilePath);
   const { tasksDir, completedDir } = getTaskStorage(rootDir);
 
@@ -318,8 +357,12 @@ function completeTask(slug, rootDir = process.cwd()) {
  * Internal helper to parse assignee families from YAML frontmatter content.
  * Supports inline array, simple inline, and block formats.
  */
+/**
+ * @param {string} content
+ * @returns {{matched: boolean, families: string[]}}
+ */
 function parseAssigneeFamilies(content) {
-  let families = [];
+  let families = /** @type {string[]} */ ([]);
   let matched = false;
 
   const lineMatch = content.match(/^assignee:[ \t]*(.*)$/m);
@@ -333,8 +376,8 @@ function parseAssigneeFamilies(content) {
         : rest;
 
       families = rawValues.split(',')
-        .map(s => s.trim().replace(/^['"]|['"]$/g, '').replace(/^@/, ''))
-        .filter(s => s.length > 0);
+        .map(/** @param {string} s */ s => s.trim().replace(/^['"]|['"]$/g, '').replace(/^@/, ''))
+        .filter(/** @param {string} s */ s => s.length > 0);
     }
   }
 
@@ -344,18 +387,24 @@ function parseAssigneeFamilies(content) {
     if (blockMatch) {
       matched = true;
       families = blockMatch[1].split(/[\r\n]+/)
-        .map(line => line.trim())
-        .filter(line => line.startsWith('-'))
-        .map(line => line.substring(1).trim().replace(/^['"]|['"]$/g, '').replace(/^@/, ''))
-        .filter(s => s.length > 0);
+        .map(/** @param {string} line */ line => line.trim())
+        .filter(/** @param {string} line */ line => line.startsWith('-'))
+        .map(/** @param {string} line */ line => line.substring(1).trim().replace(/^['"]|['"]$/g, '').replace(/^@/, ''))
+        .filter(/** @param {string} s */ s => s.length > 0);
     }
   }
 
   return { matched, families };
 }
 
+/**
+ * @param {string} taskFilePath
+ * @param {string} message
+ * @param {string} [rootDir]
+ * @returns {boolean|null|void}
+ */
 function commitTaskFileUpdate(taskFilePath, message, rootDir = process.cwd()) {
-  if (!taskFilePath || !fs.existsSync(taskFilePath)) return;
+  if (!taskFilePath || !fs.existsSync(taskFilePath)) {return;}
   // Run `git add/commit` against the worktree the caller intended (rootDir),
   // not whichever branch process.cwd() happens to have checked out. All
   // worktrees share one git object store, so the only thing that pins the
@@ -380,23 +429,24 @@ function commitTaskFileUpdate(taskFilePath, message, rootDir = process.cwd()) {
       return false;
     }
     return true;
-  } catch (e) {
-    fmt.log.fail(`Git error during task update: ${e.message}`);
+  } catch (/** @type {unknown} */ e) {
+    fmt.log.fail(`Git error during task update: ${(/** @type {Error} */ (e)).message}`);
     return false;
   }
 }
 
+/** @param {string} taskFilePath @returns {boolean} */
 function clearTaskAgentAssignee(taskFilePath) {
-  if (!taskFilePath || !fs.existsSync(taskFilePath)) return false;
+  if (!taskFilePath || !fs.existsSync(taskFilePath)) {return false;}
   let content = fs.readFileSync(taskFilePath, 'utf8');
-  if (!content.match(/^assignee:/m)) return false;
+  if (!content.match(/^assignee:/m)) {return false;}
 
   const { families } = parseAssigneeFamilies(content);
   const supportedAgents = getSupportedAgents();
 
   // Separate agent families from human assignees
-  const agentFamilies = families.filter(f => supportedAgents.includes(f.toLowerCase()));
-  const humanFamilies = families.filter(f => !supportedAgents.includes(f.toLowerCase()));
+  const agentFamilies = families.filter(/** @param {string} f */ f => supportedAgents.includes(f.toLowerCase()));
+  const humanFamilies = families.filter(/** @param {string} f */ f => !supportedAgents.includes(f.toLowerCase()));
 
   // If there are no agent families to clear, nothing to do — preserve human assignees
   if (agentFamilies.length === 0) {
@@ -410,7 +460,7 @@ function clearTaskAgentAssignee(taskFilePath) {
       // Remove agent families and write back human-only
       let newAssigneeLine;
       if (hasBlockForm) {
-        newAssigneeLine = 'assignee:\n' + humanFamilies.map(f => `  - ${f}`).join('\n') + '\n';
+        newAssigneeLine = 'assignee:\n' + humanFamilies.map(/** @param {string} f */ f => `  - ${f}`).join('\n') + '\n';
       } else {
         newAssigneeLine = `assignee: [${humanFamilies.join(', ')}]`;
       }
@@ -442,7 +492,7 @@ function clearTaskAgentAssignee(taskFilePath) {
     if (blockLines) {
       const keptLines = blockLines[1].split('\n').filter(line => {
         const m = line.match(/^\s+-\s+(.+)/);
-        if (!m) return line.trim() === '';
+        if (!m) {return line.trim() === '';}
         const family = m[1].trim().replace(/^['"]|['"]$/g, '');
         return !supportedAgents.includes(family.toLowerCase());
       }).join('\n');
@@ -465,6 +515,12 @@ function clearTaskAgentAssignee(taskFilePath) {
  * restoring a prior assignee, or clearing agent assignees,
  * and commit the change to the mission branch.
  */
+/**
+ * @param {string} slug
+ * @param {string} newStatus
+ * @param {{implementer?: string|null, clearAssignee?: boolean, rootDir?: string, log?: Function}} [opts]
+ * @returns {boolean}
+ */
 function transitionTask(slug, newStatus, { implementer = null, clearAssignee = false, rootDir = process.cwd(), log = fmt.log.plain } = {}) {
   const resolution = resolveTaskFile(slug, rootDir);
   if (!resolution.ok) {
@@ -472,7 +528,7 @@ function transitionTask(slug, newStatus, { implementer = null, clearAssignee = f
     return false;
   }
 
-  const taskFile = resolution.taskFile;
+  const taskFile = /** @type {string} */ (resolution.taskFile);
 
   // Guard: reject suffixed slugs (e.g. "task-1048-regress") to prevent
   // resolveTaskFile's base-ID fallback from silently committing to the
@@ -507,7 +563,7 @@ function transitionTask(slug, newStatus, { implementer = null, clearAssignee = f
 
   if (changed) {
     let msg = `backlog(${slug}): transition to ${newStatus}`;
-    if (implementer) msg += ` and implementer=${implementer}`;
+    if (implementer) {msg += ` and implementer=${implementer}`;}
     
     if (commitTaskFileUpdate(taskFile, msg, rootDir)) {
       log(fmt.status('PASS', `Task ${fmt.slug(slug)} transitioned to ${newStatus}${implementer ? ' (assignee=' + fmt.agent(implementer) + ')' : ''} and committed.`));
@@ -519,77 +575,107 @@ function transitionTask(slug, newStatus, { implementer = null, clearAssignee = f
   return true; // Already in the desired state
 }
 
+/** @param {string} taskFilePath @returns {string|null} */
 function getTaskAssignee(taskFilePath) {
-  if (!taskFilePath || !fs.existsSync(taskFilePath)) return null;
+  if (!taskFilePath || !fs.existsSync(taskFilePath)) {return null;}
   const content = fs.readFileSync(taskFilePath, 'utf8');
   const { families } = parseAssigneeFamilies(content);
   return families.length > 0 ? families[0] : null;
 }
 
+/** @param {string} taskFilePath @returns {string|null} */
 function getTaskImplementer(taskFilePath) {
-  if (!taskFilePath || !fs.existsSync(taskFilePath)) return null;
+  if (!taskFilePath || !fs.existsSync(taskFilePath)) {return null;}
   const content = fs.readFileSync(taskFilePath, 'utf8');
   const { families } = parseAssigneeFamilies(content);
 
-  const normalizedFamilies = families.map(f => f.toLowerCase());
+  const normalizedFamilies = families.map(/** @param {string} f */ f => f.toLowerCase());
   const supportedAgents = getSupportedAgents();
-  return normalizedFamilies.find(f => supportedAgents.includes(f)) || null;
+  return normalizedFamilies.find(/** @param {string} f */ f => supportedAgents.includes(f)) || null;
 }
 
+/** @param {string} taskFilePath @param {string} field @returns {string|null} */
 function getTaskFrontmatterValue(taskFilePath, field) {
-  if (!taskFilePath || !fs.existsSync(taskFilePath)) return null;
+  if (!taskFilePath || !fs.existsSync(taskFilePath)) {return null;}
   const content = fs.readFileSync(taskFilePath, 'utf8');
   const pattern = new RegExp(`^${field}:\\s*([^\\r\\n]+)`, 'mi');
   const match = content.match(pattern);
-  if (!match) return null;
+  if (!match) {return null;}
   const value = match[1].trim().replace(/^['"]|['"]$/g, '');
   return value || null;
 }
 
-function getTaskClassification(taskFilePath) {
-  if (!taskFilePath || !fs.existsSync(taskFilePath)) return null;
+const CLASSIFICATION_LABELS = new Set(['ai_sdlc', 'user_value', 'unknown']);
+
+/**
+ * Parse all labels from a task file's frontmatter, supporting both block
+ * and inline YAML formats. Returns a lowercased array of label strings.
+ * When both formats are present, block labels take precedence (inline is
+ * treated as a fallback when no block labels are found).
+ */
+/** @param {string} taskFilePath */
+function getTaskLabels(taskFilePath) {
+  if (!taskFilePath || !fs.existsSync(taskFilePath)) {return [];}
   const content = fs.readFileSync(taskFilePath, 'utf8');
-  const matches = new Set();
 
   const blockMatch = content.match(/^labels:[ \t]*[\r\n]+((?:\s+-\s+.+[\r\n]*)+)/m);
   if (blockMatch) {
-    const labels = blockMatch[1].split(/[\r\n]+/)
+    return blockMatch[1].split(/[\r\n]+/)
       .map(line => line.trim())
       .filter(line => line.startsWith('-'))
       .map(line => line.substring(1).trim().replace(/^['"]|['"]$/g, ''))
-      .map(s => s.toLowerCase());
-    if (labels.includes('ai_sdlc')) matches.add('ai_sdlc');
-    if (labels.includes('user_value')) matches.add('user_value');
-    if (labels.includes('unknown')) matches.add('unknown');
+      .map(s => s.toLowerCase())
+      .filter(s => s.length > 0);
   }
 
   const inlineMatch = content.match(/^labels:[ \t]*\[(.*?)\]/m);
   if (inlineMatch) {
-    const labels = inlineMatch[1].split(',')
+    return inlineMatch[1].split(',')
       .map(s => s.trim().replace(/^['"]|['"]$/g, ''))
-      .map(s => s.toLowerCase());
-    if (labels.includes('ai_sdlc')) matches.add('ai_sdlc');
-    if (labels.includes('user_value')) matches.add('user_value');
-    if (labels.includes('unknown')) matches.add('unknown');
+      .map(s => s.toLowerCase())
+      .filter(s => s.length > 0);
   }
 
+  return [];
+}
+
+/** @param {string} taskFilePath */
+function getTaskClassification(taskFilePath) {
+  if (!taskFilePath || !fs.existsSync(taskFilePath)) {return null;}
+  const labels = getTaskLabels(taskFilePath);
+  const matches = new Set();
+  for (const label of labels) {
+    if (CLASSIFICATION_LABELS.has(label)) {matches.add(label);}
+  }
   return matches.size === 1 ? [...matches][0] : null;
 }
 
+/** @param {string} taskFilePath */
+function hasBugLabel(taskFilePath) {
+  const labels = getTaskLabels(taskFilePath);
+  return labels.includes('bug');
+}
+
 
+/**
+ * @param {string} taskFilePath
+ * @param {string} agentFamily
+ * @param {{promote?: boolean}} [opts]
+ * @returns {boolean}
+ */
 function setTaskAssignee(taskFilePath, agentFamily, { promote = true } = {}) {
-  if (!taskFilePath || !fs.existsSync(taskFilePath)) return false;
+  if (!taskFilePath || !fs.existsSync(taskFilePath)) {return false;}
   let content = fs.readFileSync(taskFilePath, 'utf8');
 
   const { matched, families } = parseAssigneeFamilies(content);
 
   if (matched) {
     const lowerAgentFamily = agentFamily.toLowerCase();
-    const existingIndex = families.findIndex(f => f.toLowerCase() === lowerAgentFamily);
+    const existingIndex = families.findIndex(/** @param {string} f */ f => f.toLowerCase() === lowerAgentFamily);
 
     if (existingIndex !== 0) {
       if (existingIndex !== -1) {
-        if (!promote) return false; // Already in the list, and we don't want to move it
+        if (!promote) {return false;} // Already in the list, and we don't want to move it
         // Remove existing to promote to first
         families.splice(existingIndex, 1);
       }
@@ -620,7 +706,7 @@ function setTaskAssignee(taskFilePath, agentFamily, { promote = true } = {}) {
 
   // No assignee line exists — insert one after the id frontmatter line
   const insertMatch = content.match(/^(id:.*)/m);
-  if (insertMatch) {
+  if (insertMatch && insertMatch.index !== undefined) {
     const insertPos = insertMatch.index + insertMatch[0].length;
     const newLine = '\nassignee: [' + agentFamily + ']';
     content = content.slice(0, insertPos) + newLine + content.slice(insertPos);
@@ -631,8 +717,9 @@ function setTaskAssignee(taskFilePath, agentFamily, { promote = true } = {}) {
   return false;
 }
 
+/** @param {string} taskFilePath @param {string} agentFamily @returns {boolean} */
 function setTaskImplementer(taskFilePath, agentFamily) {
-  if (!taskFilePath || !fs.existsSync(taskFilePath)) return false;
+  if (!taskFilePath || !fs.existsSync(taskFilePath)) {return false;}
   let content = fs.readFileSync(taskFilePath, 'utf8');
 
   const { matched, families } = parseAssigneeFamilies(content);
@@ -644,13 +731,13 @@ function setTaskImplementer(taskFilePath, agentFamily) {
   const nextFamilies = [agentFamily, ...preservedFamilies];
 
   if (matched) {
-    const normalizedCurrent = families.map(f => f.toLowerCase());
-    const normalizedNext = nextFamilies.map(f => f.toLowerCase());
+    const normalizedCurrent = families.map(/** @param {string} f */ f => f.toLowerCase());
+    const normalizedNext = nextFamilies.map(/** @param {string} f */ f => f.toLowerCase());
     // Check if the first agent is already the one we want to set
     if (normalizedCurrent.length > 0 && normalizedCurrent[0] === agentFamily.toLowerCase()) {
       // If the rest of the list is also the same, it's a no-op
       if (normalizedCurrent.length === normalizedNext.length &&
-          normalizedCurrent.every((f, i) => f === normalizedNext[i])) {
+          normalizedCurrent.every((f, /** @type {number} */ i) => f === normalizedNext[i])) {
         return false;
       }
     }
@@ -670,7 +757,7 @@ function setTaskImplementer(taskFilePath, agentFamily) {
   }
 
   const insertMatch = content.match(/^(id:.*)/m);
-  if (insertMatch) {
+  if (insertMatch && insertMatch.index !== undefined) {
     const insertPos = insertMatch.index + insertMatch[0].length;
     const newLine = '\nassignee: [' + agentFamily + ']';
     content = content.slice(0, insertPos) + newLine + content.slice(insertPos);
@@ -681,12 +768,13 @@ function setTaskImplementer(taskFilePath, agentFamily) {
   return false;
 }
 
+/** @param {string} taskFilePath @param {string} agentFamily @returns {boolean} */
 function enforceTaskAssignee(taskFilePath, agentFamily) {
-  if (!taskFilePath || !fs.existsSync(taskFilePath)) return false;
+  if (!taskFilePath || !fs.existsSync(taskFilePath)) {return false;}
   let content = fs.readFileSync(taskFilePath, 'utf8');
 
   const { families } = parseAssigneeFamilies(content);
-  if (families.length === 1 && families[0] === agentFamily) return true;
+  if (families.length === 1 && families[0] === agentFamily) {return true;}
 
   const newAssignee = `assignee: [${agentFamily}]`;
 
@@ -696,7 +784,7 @@ function enforceTaskAssignee(taskFilePath, agentFamily) {
     content = content.replace(/^assignee:[ \t]*.*$/m, newAssignee);
   } else {
     const insertMatch = content.match(/^(id:.*)/m);
-    if (!insertMatch) return false;
+    if (!insertMatch || insertMatch.index === undefined) {return false;}
     const insertPos = insertMatch.index + insertMatch[0].length;
     content = content.slice(0, insertPos) + '\n' + newAssignee + content.slice(insertPos);
   }
@@ -705,11 +793,12 @@ function enforceTaskAssignee(taskFilePath, agentFamily) {
   return true;
 }
 
+/** @param {string} taskFilePath @returns {string[]} */
 function getAcceptanceCriteria(taskFilePath) {
-  if (!taskFilePath || !fs.existsSync(taskFilePath)) return [];
+  if (!taskFilePath || !fs.existsSync(taskFilePath)) {return [];}
   const content = fs.readFileSync(taskFilePath, 'utf8');
   const sectionMatch = content.match(/## Acceptance Criteria\s*\n([\s\S]*?)(?:\n## |\nDefinition of Done:|\n---\n|$)/);
-  if (!sectionMatch) return [];
+  if (!sectionMatch) {return [];}
 
   return sectionMatch[1]
     .split('\n')
@@ -734,6 +823,8 @@ module.exports = {
   getTaskImplementer,
   getTaskFrontmatterValue,
   getTaskClassification,
+  getTaskLabels,
+  hasBugLabel,
   setTaskAssignee,
   setTaskImplementer,
   enforceTaskAssignee,