@magnusekdahl/parallix 1.1.0 → 1.2.0

package/lib/commands/diff.js

@@ -4,6 +4,7 @@ const { git } = require('../core/git');
 const { getPrimaryBranch, missionBranchName, inferSlug, resolveWorktree } = require('../core/mission-utils');
 const fmt = require('../core/fmt');
 
+/** @param {string[]} args @param {{gitFn?: Function, spawnSyncFn?: Function, getPrimaryBranchFn?: Function, missionBranchNameFn?: Function, inferSlugFn?: Function, resolveWorktreeFn?: Function, exitFn?: Function, failFn?: Function}} opts */
 async function diff(args, {
   gitFn = git,
   spawnSyncFn = childProcess.spawnSync,
@@ -14,6 +15,7 @@ async function diff(args, {
   exitFn = process.exit,
   failFn = fmt.log.fail,
 } = {}) {
+  /** @param {string} a */
   const explicitSlug = args.filter(a => !a.startsWith('--'))[0];
   const slug = inferSlugFn(explicitSlug);
 
@@ -34,7 +36,7 @@ async function diff(args, {
   try {
     primary = getPrimaryBranchFn(worktree);
   } catch (err) {
-    failFn(err.message);
+    failFn(/** @type{Error} */(err).message);
     exitFn(1);
     return;
   }
@@ -43,30 +45,34 @@ async function diff(args, {
   const target = `${primary}..HEAD`;
 
   // Detect configured diff tool/pager
+  /** @param {string} key */
   const getGitConfig = (key) => {
     const result = gitFn(['-C', worktree, 'config', '--get', key]);
     return result.status === 0 ? result.stdout.trim() : null;
   };
 
+  /** @param {string} cmd */
   const isSpecializedTool = (cmd) => {
-    if (!cmd) return false;
+    if (!cmd) {return false;}
     const parts = cmd.split(/\s+/);
     // Handle cases like "LESS=FRX less" or "/usr/bin/delta"
+    /** @param {string} p */
     const exePart = parts.find(p => !p.includes('='));
-    if (!exePart) return false;
+    if (!exePart) {return false;}
     const exe = path.basename(exePart).toLowerCase();
     
     // Explicitly reject known default pagers
-    if (['less', 'cat', 'more'].includes(exe)) return false;
+    if (['less', 'cat', 'more'].includes(exe)) {return false;}
     
     // Accept known specialized tools documented in review-tooling.md
-    if (['delta', 'difft', 'diff-so-fancy'].includes(exe)) return true;
+    if (['delta', 'difft', 'diff-so-fancy'].includes(exe)) {return true;}
     
     // Fallback: if it's not a known default, and we have a value, treat it as specialized
     // for now to avoid breaking custom setups like "vimdiff", but we've rejected plain "less".
     return true;
   };
 
+  /** @param {childProcess.SpawnSyncReturns<string>} result @param {string} toolName */
   const handleLaunchResult = (result, toolName) => {
     if (result.error) {
       failFn(`Failed to launch ${toolName}: ${result.error.message}`);

package/lib/commands/draft.js

@@ -4,7 +4,7 @@ const crypto = require('crypto');
 const fmt = require('../core/fmt');
 const { git, getWorktreeStatus } = require('../core/git');
 const { startDraftAgent, selectAgent, readAgentConfigOrExit } = require('../agents/agents');
-const { resolveTaskFile, enforceTaskAssignee, reportTaskResolution, checkBacklogIntegrity, transitionTask, getTaskClassification, getTaskStorage } = require('../tools/backlog');
+const { resolveTaskFile, enforceTaskAssignee, reportTaskResolution, checkBacklogIntegrity, transitionTask, getTaskStorage } = require('../tools/backlog');
 const { findMissionArea, findMissionDir, inferSlug, getMissionYear, resolveMainRepo, conventionalWorktreePath, squashTrailingBacklogNoiseIntoPreviousMission, resolveWorktree, getPrimaryBranch, missionBranchName, missionDirForSlug, detectLaunchBaseBranch } = require('../core/mission-utils');
 const { transitionVirtual } = require('../core/state-map');
 const stats = require('./stats');
@@ -17,7 +17,7 @@ const DRAFT_PROMPT_PATH = path.join(__dirname, '..', '..', 'prompts', 'draft.md'
 const MISSION_SCAFFOLD_PATH = path.join(__dirname, '..', '..', 'templates', 'mission-scaffold.md');
 const SYNTHETIC_SLUG_PREFIX = 'adhoc-';
 
-function slugifyDraftIntent(value) {
+function slugifyDraftIntent(/** @type {string} */ value) {
   return String(value || '')
     .trim()
     .toLowerCase()
@@ -28,7 +28,7 @@ function slugifyDraftIntent(value) {
     .slice(0, 64);
 }
 
-function syntheticTaskId(slug, seed) {
+function syntheticTaskId(/** @type {string} */ slug, /** @type {string} */ seed) {
   const hash = crypto.createHash('sha1').update(String(seed || slug)).digest('hex').slice(0, 8).toUpperCase();
   const prefix = slug.startsWith(SYNTHETIC_SLUG_PREFIX) ? 'ADHOC' : 'TASK';
   const base = slug
@@ -38,9 +38,9 @@ function syntheticTaskId(slug, seed) {
   return `${prefix}-${base}-${hash}`;
 }
 
-function resolveDraftTarget(rawInput, cwd = process.cwd()) {
+function resolveDraftTarget(/** @type {string} */ rawInput, cwd = process.cwd()) {
   const explicit = String(rawInput || '').trim();
-  if (!explicit) return null;
+  if (!explicit) {return null;}
 
   if (explicit.toLowerCase().startsWith('task-')) {
     return {
@@ -90,7 +90,7 @@ function resolveDraftTarget(rawInput, cwd = process.cwd()) {
   };
 }
 
-async function runDraftCommand(args, {
+async function runDraftCommand(/** @type {string[]} */ args, {
   inferSlugFn = inferSlug,
   resolveMainRepoFn = resolveMainRepo,
   conventionalWorktreePathFn = conventionalWorktreePath,
@@ -136,9 +136,9 @@ async function runDraftCommand(args, {
   const syntheticTask = draftTarget.syntheticTask;
 
   // Allow operators to pin the agent family via CLI flag instead of WORKFLOW_AGENT env var.
-  function flagValue(arr, flag, name) {
+  function flagValue(/** @type {string[]} */ arr, /** @type {string} */ flag, /** @type {string} */ name) {
     const i = arr.indexOf(flag);
-    if (i === -1) return null;
+    if (i === -1) {return null;}
     const v = arr[i + 1];
     if (!v || v.startsWith('--')) {
       errorFn(fmt.status('FAIL', `Missing value for --${name}. Usage: px draft <slug> --${name} <family>`));
@@ -178,7 +178,7 @@ async function runDraftCommand(args, {
   try {
     launchBase = detectLaunchBaseBranchFn(process.cwd());
   } catch (error) {
-    errorFn(fmt.status('FAIL', error.message));
+    errorFn(fmt.status('FAIL', /** @type {any} */ (error).message));
     exitFn(1);
     return;
   }
@@ -208,9 +208,9 @@ async function runDraftCommand(args, {
     errorFn(fmt.status('FAIL', `Backlog integrity issues detected for ${normalizedSlug}:`));
     relevantIssues.forEach(issue => {
       if (issue.type === 'duplicate-completed') {
-        logFn(`  - ${fmt.path(issue.file)}: task ${fmt.bold(issue.taskId)} already has a canonical copy in ${fmt.path(issue.canonicalFile)}; this backlog/tasks copy is stale.`);
+        logFn(`  - ${fmt.path(/** @type {any} */ (issue).file)}: task ${fmt.bold(/** @type {any} */ (issue).taskId)} already has a canonical copy in ${fmt.path(/** @type {any} */ (issue).canonicalFile)}; this backlog/tasks copy is stale.`);
       } else {
-        logFn(`  - ${fmt.path(issue.file)}: filename ID (${fmt.bold(issue.filenameId)}) does not match frontmatter ID (${fmt.bold(issue.frontmatterId)})`);
+        logFn(`  - ${fmt.path(/** @type {any} */ (issue).file)}: filename ID (${fmt.bold(/** @type {any} */ (issue).filenameId)}) does not match frontmatter ID (${fmt.bold(/** @type {any} */ (issue).frontmatterId)})`);
       }
     });
     logFn('Repair: Fix filename/id mismatch, or remove the stale backlog/tasks copy of a completed/archived task, before drafting.');
@@ -244,7 +244,7 @@ async function runDraftCommand(args, {
   ensureMissionBaseBranchRecordedFn(missionFile, recordedBase, { logFn });
 
   logFn(fmt.bold('Step 4: Ensuring Backlog task exists in worktree...'));
-  if (!bootstrapBacklogTaskFn(targetWorktree, mainRepo, normalizedSlug, { logFn, errorFn, syntheticTask })) {
+  if (!bootstrapBacklogTaskFn(targetWorktree, mainRepo, normalizedSlug, { logFn, errorFn, syntheticTask: /** @type {null | undefined} */ (syntheticTask) })) {
     const { tasksDir } = getTaskStorage(targetWorktree);
     const taskDirHint = path.relative(targetWorktree, tasksDir).split(path.sep).join('/');
     errorFn(fmt.status('FAIL', `Backlog task for ${normalizedSlug} could not be prepared in the mission worktree.`));
@@ -276,23 +276,25 @@ async function runDraftCommand(args, {
   const agentConfig = readAgentConfigOrExitFn();
   const agent = preselectedAgent || selectAgentFn('draft', { config: agentConfig });
 
-  const prompt = buildDraftPrompt(normalizedSlug, { rootDir: mainRepo, worktree: targetWorktree });
+  // @ts-expect-error buildDraftPrompt type mismatch
+  const prompt = buildDraftPrompt(normalizedSlug, { rootDir: mainRepo, worktree: targetWorktree || '' });
   logFn('Launching draft agent...');
   const { agent: actualAgent, result } = await startDraftAgentFn({
     prompt,
+    // @ts-expect-error worktree not in type
     worktree: targetWorktree,
     agent
   });
-  logFn(`Draft agent family: ${fmt.agent(actualAgent)}`);
+  logFn(`Draft agent family: ${fmt.agent(/** @type {any} */ (actualAgent))}`);
 
   if (result.error) {
-    errorFn(fmt.status('FAIL', `Could not start draft agent (${fmt.agent(actualAgent)}): ${result.error.message}`));
+    errorFn(fmt.status('FAIL', `Could not start draft agent (${fmt.agent(/** @type {any} */ (actualAgent))}): ${/** @type {any} */ (result.error).message}`));
     exitFn(1);
     return;
   }
 
-  if (typeof result.status === 'number' && result.status !== 0) {
-    errorFn(fmt.status('FAIL', `Draft agent (${fmt.agent(actualAgent)}) exited with status ${result.status}.`));
+  if (typeof /** @type {any} */ (result).status === 'number' && /** @type {any} */ (result).status !== 0) {
+    errorFn(fmt.status('FAIL', `Draft agent (${fmt.agent(/** @type {any} */ (actualAgent))}) exited with status ${/** @type {any} */ (result).status}.`));
     exitFn(result.status || 1);
     return;
   }
@@ -315,6 +317,7 @@ async function runDraftCommand(args, {
     agentFamily: actualAgent,
     result,
     log: logFn,
+    // @ts-expect-error reportTaskResolutionFn accepts extra properties
     error: errorFn
   });
 
@@ -328,6 +331,7 @@ async function runDraftCommand(args, {
     const restartOk = await restartDraftAgentFn(normalizedSlug, targetWorktree, {
       logFn,
       errorFn,
+      // @ts-expect-error restartDraftAgentFn accepts extra properties
       exitFn
     });
     if (!restartOk) {
@@ -355,12 +359,12 @@ async function runDraftCommand(args, {
   try {
     enforceDraftCommitSafetyFn({ slug: normalizedSlug, worktree: targetWorktree, logFn, errorFn });
   } catch (error) {
-    errorFn(fmt.status('FAIL', error.message));
+    errorFn(fmt.status('FAIL', /** @type {any} */ (error).message));
     exitFn(1);
     return;
   }
 
-  if (!transitionVirtualFn(transitionTaskFn, normalizedSlug, 'ready', { rootDir: targetWorktree, log: logFn })) {
+  if (!transitionVirtualFn(transitionTaskFn, normalizedSlug, 'ready', /** @type {{ rootDir: string, log: Function }} */ ({ rootDir: targetWorktree, log: logFn }))) {
     errorFn(fmt.status('FAIL', `Could not transition task ${normalizedSlug} to ready status.`));
     exitFn(1);
     return;
@@ -369,18 +373,24 @@ async function runDraftCommand(args, {
   logFn('\n' + fmt.status('INFO', `Next: ${fmt.command(`cd ${targetWorktree}`)}`));
 }
 
+// @ts-expect-error implicit any on args/deps
 async function draft(args, deps) {
   return runDraftCommand(args, deps);
 }
 
 function recordDraftImplementer({
+  // @ts-expect-error implicit any binding elements
   selected,
+  // @ts-expect-error implicit any binding elements
   actual,
+  // @ts-expect-error implicit any binding elements
   taskResolution,
   log = fmt.log.plain,
   enforceTaskAssigneeFn = enforceTaskAssignee,
   gitFn = git,
+  // @ts-expect-error implicit any binding elements
   slug,
+  // @ts-expect-error implicit any binding elements
   worktree
 }) {
   if (!taskResolution || !taskResolution.ok || !actual) {
@@ -408,6 +418,7 @@ function recordDraftImplementer({
   return actual;
 }
 
+// @ts-expect-error implicit any on mainRepo/branchName
 function ensureMissionBranch(mainRepo, branchName, {
   gitFn = git,
   logFn = fmt.log.plain,
@@ -436,6 +447,7 @@ function ensureMissionBranch(mainRepo, branchName, {
  * detached-HEAD launch) or when the correct line is already present. Replaces a
  * stale line in place, otherwise inserts the line just under the title.
  */
+// @ts-expect-error implicit any on missionFile/baseBranch
 function ensureMissionBaseBranchRecorded(missionFile, baseBranch, { logFn = fmt.log.plain } = {}) {
   if (!baseBranch || !missionFile || !fs.existsSync(missionFile)) {
     return false;
@@ -463,6 +475,7 @@ function ensureMissionBaseBranchRecorded(missionFile, baseBranch, { logFn = fmt.
   return true;
 }
 
+// @ts-expect-error implicit any on mainRepo/targetWorktree/branchName
 function ensureWorktree(mainRepo, targetWorktree, branchName, {
   existsFn = fs.existsSync,
   gitFn = git,
@@ -484,11 +497,12 @@ function ensureWorktree(mainRepo, targetWorktree, branchName, {
     gitFn(['-C', mainRepo, 'worktree', 'add', targetWorktree, branchName]);
     logFn(fmt.status('PASS', `Created worktree at ${fmt.path(targetWorktree)}.`));
   } catch (error) {
-    errorFn(fmt.status('FAIL', `Could not create worktree: ${error.message}`));
+    errorFn(fmt.status('FAIL', `Could not create worktree: ${/** @type {any} */ (error).message}`));
     exitFn(1);
   }
 }
 
+// @ts-expect-error implicit any on targetWorktree
 function ensureGraphifyWorkspace(targetWorktree, { logFn = fmt.log.plain } = {}) {
   const targetPath = path.join(targetWorktree, 'graphify-out');
 
@@ -511,6 +525,7 @@ function ensureGraphifyWorkspace(targetWorktree, { logFn = fmt.log.plain } = {})
   return true;
 }
 
+// @ts-expect-error implicit any on targetWorktree
 function ensureGraphifyIgnore(targetWorktree, { gitFn = git, logFn = fmt.log.plain } = {}) {
   const targetPath = path.join(targetWorktree, '.graphifyignore');
 
@@ -538,12 +553,13 @@ function ensureGraphifyIgnore(targetWorktree, { gitFn = git, logFn = fmt.log.pla
     gitFn(['-C', gitRoot, 'commit', '-m', 'workflow: add .graphifyignore to exclude .workflow/ from graphify']);
     logFn(fmt.status('PASS', `Created and committed .graphifyignore in ${fmt.path(gitRoot)}.`));
   } catch (error) {
-    logFn(fmt.status('WARN', `Created .graphifyignore but could not commit: ${error.message}. It will be picked up by the draft safety harness.`));
+    logFn(fmt.status('WARN', `Created .graphifyignore but could not commit: ${/** @type {any} */ (error).message}. It will be picked up by the draft safety harness.`));
   }
 
   return true;
 }
 
+// @ts-expect-error implicit any on targetWorktree/slug
 function ensureMissionFile(targetWorktree, slug, { logFn = fmt.log.plain } = {}) {
   const missionDir = missionDirForSlug(targetWorktree, slug);
   if (!fs.existsSync(missionDir)) {
@@ -563,6 +579,7 @@ function ensureMissionFile(targetWorktree, slug, { logFn = fmt.log.plain } = {})
   return missionFile;
 }
 
+// @ts-expect-error implicit any on mainRepo
 function ensureDraftRepoConfigCommitted(mainRepo, {
   getWorktreeStatusFn = getWorktreeStatus,
   errorFn = fmt.log.plainError
@@ -593,6 +610,7 @@ function ensureDraftRepoConfigCommitted(mainRepo, {
   return false;
 }
 
+// @ts-expect-error implicit any on targetWorktree/mainRepo/slug
 function bootstrapBacklogTask(targetWorktree, mainRepo, slug, {
   resolveTaskFileFn = resolveTaskFile,
   reportTaskResolutionFn = reportTaskResolution,
@@ -614,11 +632,11 @@ function bootstrapBacklogTask(targetWorktree, mainRepo, slug, {
 
   if (syntheticTask) {
     const { tasksDir } = getTaskStorage(targetWorktree);
-    const taskPath = path.join(tasksDir, `${slug} - ${slugifyDraftIntent(syntheticTask.title || slug) || 'mission'}.md`);
+    const taskPath = path.join(tasksDir, `${slug} - ${slugifyDraftIntent(/** @type {any} */ (syntheticTask).title || slug) || 'mission'}.md`);
     const body = [
       '---',
-      `id: ${syntheticTask.id || syntheticTaskId(slug, syntheticTask.intent || slug)}`,
-      `title: ${syntheticTask.title || slug}`,
+      `id: ${/** @type {any} */ (syntheticTask).id || syntheticTaskId(slug, /** @type {any} */ (syntheticTask).intent || slug)}`,
+      `title: ${/** @type {any} */ (syntheticTask).title || slug}`,
       'status: backlog',
       'assignee: []',
       "created_date: '" + new Date().toISOString().slice(0, 16).replace('T', ' ') + "'",
@@ -629,7 +647,7 @@ function bootstrapBacklogTask(targetWorktree, mainRepo, slug, {
       '',
       '## Description',
       '',
-      syntheticTask.intent || `Synthetic task created for ${slug}.`,
+      /** @type {any} */ (syntheticTask).intent || `Synthetic task created for ${slug}.`,
       ''
     ].join('\n');
 
@@ -643,7 +661,7 @@ function bootstrapBacklogTask(targetWorktree, mainRepo, slug, {
       gitFn(['-C', targetWorktree, 'commit', '-m', `backlog(${slug}): create synthetic task`]);
       logFn(fmt.status('PASS', 'Committed synthetic task in worktree.'));
     } catch (error) {
-      errorFn(fmt.status('FAIL', `Could not commit synthetic task: ${error.message}`));
+      errorFn(fmt.status('FAIL', `Could not commit synthetic task: ${/** @type {any} */ (error).message}`));
       return false;
     }
     return true;
@@ -656,10 +674,12 @@ function bootstrapBacklogTask(targetWorktree, mainRepo, slug, {
     return false;
   }
 
+  // @ts-expect-error mainResolution.taskFile may be undefined
   const relativePath = path.relative(mainRepo, mainResolution.taskFile);
-  const targetPath = path.join(targetWorktree, relativePath);
+  const targetPath = path.join(targetWorktree || '', relativePath);
 
   fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  // @ts-expect-error mainResolution.taskFile may be undefined
   fs.copyFileSync(mainResolution.taskFile, targetPath);
 
   logFn(fmt.status('PASS', `Bootstrapped ${fmt.path(relativePath)} from main repo.`));
@@ -669,17 +689,19 @@ function bootstrapBacklogTask(targetWorktree, mainRepo, slug, {
     gitFn(['-C', targetWorktree, 'commit', '-m', `backlog(${slug}): bootstrap task from ${getPrimaryBranch()}`]);
     logFn(fmt.status('PASS', 'Committed bootstrapped task in worktree.'));
   } catch (error) {
-    errorFn(fmt.status('FAIL', `Could not commit bootstrapped task: ${error.message}`));
+    errorFn(fmt.status('FAIL', `Could not commit bootstrapped task: ${/** @type {any} */ (error).message}`));
     return false;
   }
 
   return true;
 }
 
+// @ts-expect-error implicit any on rootDir
 function resolveVerifyCmd(rootDir) {
-  return formatVerificationCommand(null, rootDir);
+  return formatVerificationCommand(undefined, rootDir);
 }
 
+// @ts-expect-error implicit any on slug/promptRoot
 function resolveTaskPath(slug, promptRoot) {
   const resolution = resolveTaskFile(slug, promptRoot);
   if (resolution && resolution.ok && resolution.taskFile) {
@@ -688,6 +710,7 @@ function resolveTaskPath(slug, promptRoot) {
   return path.join(promptRoot, 'backlog', 'tasks', `<${slug}>.md`);
 }
 
+// @ts-expect-error implicit any on taskPath
 function resolveClassificationInstructions(taskPath) {
   if (taskPath && fs.existsSync(taskPath)) {
     const content = fs.readFileSync(taskPath, 'utf8');
@@ -695,9 +718,10 @@ function resolveClassificationInstructions(taskPath) {
       return 'because this task was synthesized by the harness, preserve the `unknown` label unless you have concrete repo-specific evidence to replace it. Do not add a separate frontmatter field for mission type.';
     }
   }
-  return 'set exactly one of `ai_sdlc` or `user_value` in the Backlog task labels — no other value. Use `ai_sdlc` for workflow, prompt, or agent-fix work; use `user_value` for everything else (including code tech debt). Do not add a separate frontmatter field for mission type.';
+  return 'set exactly one of `ai_sdlc` or `user_value` in the Backlog task labels — plus optionally `bug` for bug-fix missions. Use `ai_sdlc` for workflow, prompt, or agent-fix work; use `user_value` for everything else (including code tech debt). Do not add a separate frontmatter field for mission type.';
 }
 
+// @ts-expect-error implicit any on slug/rootDir/worktree
 function buildDraftPrompt(slug, { rootDir = process.cwd(), worktree = null } = {}) {
   const template = fs.readFileSync(DRAFT_PROMPT_PATH, 'utf8');
   const promptRoot = worktree || rootDir;
@@ -715,10 +739,12 @@ function buildDraftPrompt(slug, { rootDir = process.cwd(), worktree = null } = {
     .replaceAll('{{verifyCmd}}', resolveVerifyCmd(promptRoot));
 }
 
+// @ts-expect-error implicit any on slug
 function fallbackDraftCommitMessage(slug) {
   return `draft(${slug}): capture agent output`;
 }
 
+// @ts-expect-error implicit any on slug/worktree
 function validateDraftClassification(slug, worktree, {
   resolveMissionClassificationFn = stats.resolveMissionClassification,
   errorFn = fmt.log.plainError
@@ -726,19 +752,20 @@ function validateDraftClassification(slug, worktree, {
   try {
     const { classification, error: classificationError } = resolveMissionClassificationFn(slug, worktree);
     if (!classification) {
-      if (classificationError) errorFn(fmt.status('FAIL', classificationError));
+      if (classificationError) {errorFn(fmt.status('FAIL', classificationError));}
       return { ok: true, classification: null };
     }
     return { ok: true, classification };
   } catch (error) {
-    if (error.message.includes('Missing or invalid classification')) {
+    if (/** @type {any} */ (error).message.includes('Missing or invalid classification')) {
       return { ok: true, classification: null };
     }
-    errorFn(fmt.status('FAIL', error.message));
+    errorFn(fmt.status('FAIL', /** @type {any} */ (error).message));
     return { ok: false, reason: 'invalid-classification' };
   }
 }
 
+// @ts-expect-error implicit any on slug/worktree
 function normalizeDraftClassification(slug, worktree, {
   resolveMissionClassificationFn = stats.resolveMissionClassification,
   errorFn = fmt.log.plainError
@@ -746,59 +773,62 @@ function normalizeDraftClassification(slug, worktree, {
   try {
     const { classification, error: classificationError } = resolveMissionClassificationFn(slug, worktree);
     if (!classification) {
-      if (classificationError) errorFn(fmt.status('FAIL', classificationError));
+      if (classificationError) {errorFn(fmt.status('FAIL', classificationError));}
       return { ok: false, reason: 'missing-classification' };
     }
     return { ok: true, classification };
   } catch (error) {
-    if (error.message.includes('Missing or invalid classification')) {
+    if (/** @type {any} */ (error).message.includes('Missing or invalid classification')) {
       return { ok: false, reason: 'missing-classification' };
     }
-    errorFn(fmt.status('FAIL', error.message));
+    errorFn(fmt.status('FAIL', /** @type {any} */ (error).message));
     return { ok: false, reason: 'invalid-classification' };
   }
 }
 
+// @ts-expect-error implicit any on slug/rootDir/worktree
 function buildRestartPrompt(slug, { rootDir = process.cwd(), worktree = null } = {}) {
   return `${buildDraftPrompt(slug, { rootDir, worktree })}
 
 Focused repair:
-- update the backlog task so labels contain exactly one of \`ai_sdlc\` or \`user_value\`
+- update the backlog task so labels contain exactly one of \`ai_sdlc\` or \`user_value\` (plus optionally \`bug\` if this is a bug fix)
 - use \`ai_sdlc\` for workflow, prompt, or agent-fix work; use \`user_value\` for everything else, including standard code tech debt
 - do not add a separate frontmatter field for mission type
-- if both labels are present, keep only the correct one
+- if both classification labels are present, keep only the correct one
 `;
 }
 
+// @ts-expect-error implicit any on slug/worktree
 async function restartDraftAgent(slug, worktree, {
   selectAgentFn = selectAgent,
   startDraftAgentFn = startDraftAgent,
   readAgentConfigOrExitFn = readAgentConfigOrExit,
   logFn = fmt.log.plain,
-  errorFn = fmt.log.plainError,
-  exitFn = process.exit
+  errorFn = fmt.log.plainError
 } = {}) {
   const agentConfig = readAgentConfigOrExitFn();
   const agent = selectAgentFn('draft', { config: agentConfig });
 
   const prompt = buildRestartPrompt(slug, { rootDir: worktree, worktree });
   logFn('Relaunching draft agent to repair mission type labels...');
+  // @ts-expect-error startDraftAgentFn accepts extra properties
   const { agent: actualAgent, result } = await startDraftAgentFn({ prompt, worktree, agent });
-  logFn(`Restart draft agent family: ${fmt.agent(actualAgent)}`);
+  logFn(`Restart draft agent family: ${fmt.agent(/** @type {any} */ (actualAgent))}`);
 
   if (result.error) {
-    errorFn(fmt.status('FAIL', `Could not restart draft agent (${fmt.agent(actualAgent)}): ${result.error.message}`));
+    errorFn(fmt.status('FAIL', `Could not restart draft agent (${fmt.agent(/** @type {any} */ (actualAgent))}): ${/** @type {any} */ (result.error).message}`));
     return false;
   }
 
-  if (typeof result.status === 'number' && result.status !== 0) {
-    errorFn(fmt.status('FAIL', `Restart draft agent (${fmt.agent(actualAgent)}) exited with status ${result.status}.`));
+  if (typeof /** @type {any} */ (result).status === 'number' && /** @type {any} */ (result).status !== 0) {
+    errorFn(fmt.status('FAIL', `Restart draft agent (${fmt.agent(/** @type {any} */ (actualAgent))}) exited with status ${/** @type {any} */ (result).status}.`));
     return false;
   }
 
   return true;
 }
 
+// @ts-expect-error implicit any on entry
 function parseDirtyEntry(entry) {
   const match = entry.match(/^(.{1,2})\s+(.*)$/);
   const status = (match ? match[1] : entry.slice(0, 2)).padEnd(2, ' ');
@@ -816,20 +846,24 @@ function parseDirtyEntry(entry) {
   return { status, filePath, sourcePath };
 }
 
+// @ts-expect-error implicit any on status
 function isUnmergedStatus(status) {
   return ['DD', 'AU', 'UD', 'UA', 'DU', 'AA', 'UU'].includes(status);
 }
 
+// @ts-expect-error implicit any on status
 function isDeletedStatus(status) {
   return status.includes('D') && !isUnmergedStatus(status);
 }
 
+// @ts-expect-error implicit any on filePath/slug
 function isMissionTaskPath(filePath, slug) {
-  if (!filePath) return false;
+  if (!filePath) {return false;}
   const taskPattern = new RegExp(`^backlog/(?:tasks|completed)/[^/]*${slug}(?:\\b|[^/]*$)`);
   return taskPattern.test(filePath);
 }
 
+// @ts-expect-error implicit any on filePath/slug/worktree
 function isExpectedDraftPath(filePath, slug, worktree) {
   const missionDir = findMissionDir(slug, worktree);
   const missionPrefix = missionDir
@@ -838,21 +872,23 @@ function isExpectedDraftPath(filePath, slug, worktree) {
   return filePath.startsWith(missionPrefix) || isMissionTaskPath(filePath, slug);
 }
 
+// @ts-expect-error implicit any on dirtyEntries/slug/worktree
 function classifyDraftEntries(dirtyEntries, slug, worktree) {
   const parsedEntries = dirtyEntries.map(parseDirtyEntry);
-  const conflictEntries = parsedEntries.filter(entry => isUnmergedStatus(entry.status));
-  const stagedEntries = parsedEntries.filter(entry => !isUnmergedStatus(entry.status));
-  const expectedEntries = stagedEntries.filter(entry => isExpectedDraftPath(entry.filePath, slug, worktree));
-  const unexpectedEntries = stagedEntries.filter(entry => !isExpectedDraftPath(entry.filePath, slug, worktree));
+  const conflictEntries = parsedEntries.filter((/** @type {any} */ entry) => isUnmergedStatus(entry.status));
+  const stagedEntries = parsedEntries.filter((/** @type {any} */ entry) => !isUnmergedStatus(entry.status));
+  const expectedEntries = stagedEntries.filter((/** @type {any} */ entry) => isExpectedDraftPath(entry.filePath, slug, worktree));
+  const unexpectedEntries = stagedEntries.filter((/** @type {any} */ entry) => !isExpectedDraftPath(entry.filePath, slug, worktree));
 
   return { conflictEntries, expectedEntries, unexpectedEntries };
 }
 
-function resolveMissionSpecificDraftConflicts({ slug, worktree, conflictEntries, gitImpl = git, logFn = fmt.log.plain, errorFn = fmt.log.plainError }) {
-  const sharedConflicts = conflictEntries.filter(entry => !isExpectedDraftPath(entry.filePath, slug, worktree));
+// @ts-expect-error implicit any on slug/worktree/conflictEntries
+function resolveMissionSpecificDraftConflicts({ slug, worktree, conflictEntries, gitImpl = git, logFn = fmt.log.plain }) {
+  const sharedConflicts = conflictEntries.filter((/** @type {any} */ entry) => !isExpectedDraftPath(entry.filePath, slug, worktree));
   if (sharedConflicts.length > 0) {
     const area = findMissionArea(findMissionDir(slug, worktree) || missionDirForSlug(worktree, slug));
-    const sharedFiles = sharedConflicts.map(entry => entry.filePath);
+    const sharedFiles = sharedConflicts.map((/** @type {any} */ entry) => entry.filePath);
     throw new Error(
       `Draft safety harness found shared-file conflicts: ${sharedFiles.join(', ')}. ` +
       `Run "px resolve-conflict ${slug}" from ${worktree}, then re-run ${formatVerificationCommand(area, worktree)}.`
@@ -871,6 +907,7 @@ function resolveMissionSpecificDraftConflicts({ slug, worktree, conflictEntries,
   }
 }
 
+// @ts-expect-error implicit any on slug/worktree/dirtyEntries
 function enforceDraftCommitSafety({ slug, worktree, dirtyEntries = getWorktreeStatus(worktree), gitImpl = git, logFn = fmt.log.plain, errorFn = fmt.log.plainError }) {
   if (dirtyEntries.length === 0) {
     logFn(fmt.status('PASS', 'Draft safety harness: no uncommitted changes left behind.'));
@@ -883,6 +920,7 @@ function enforceDraftCommitSafety({ slug, worktree, dirtyEntries = getWorktreeSt
   }
 
   const { conflictEntries, expectedEntries, unexpectedEntries } = classifyDraftEntries(dirtyEntries, slug, worktree);
+  // @ts-expect-error errorFn not in type
   resolveMissionSpecificDraftConflicts({ slug, worktree, conflictEntries, gitImpl, logFn, errorFn });
 
   const deletedTaskEntries = [...expectedEntries, ...unexpectedEntries].filter(entry =>
@@ -937,6 +975,7 @@ function enforceDraftCommitSafety({ slug, worktree, dirtyEntries = getWorktreeSt
   return true;
 }
 
+// @ts-expect-error implicit any on mainRepo
 function ensureRepoExists(mainRepo, exitFn = process.exit, errorFn = fmt.log.fail) {
   if (!fs.existsSync(mainRepo)) {
     errorFn(`Main repository not found at ${mainRepo}. Please ensure it exists or set PRIMARY_WORKTREE.`);
@@ -952,8 +991,9 @@ function ensureRepoExists(mainRepo, exitFn = process.exit, errorFn = fmt.log.fai
  * families record honest zeros with provider/model set to the family name.
  * Best-effort: a failure here must never fail the draft.
  */
-function recordDraftStats({ slug, rootDir, agentFamily, result, log = fmt.log.plain, error = fmt.log.plainError }) {
-  if (!result) return;
+// @ts-expect-error implicit any on slug/rootDir/agentFamily/result
+function recordDraftStats({ slug, rootDir, agentFamily, result, log = fmt.log.plain }) {
+  if (!result) {return;}
   let durationMinutes = 0;
   if (result.startedAt && result.endedAt) {
     durationMinutes = (Date.parse(result.endedAt) - Date.parse(result.startedAt)) / 60000;
@@ -971,7 +1011,7 @@ function recordDraftStats({ slug, rootDir, agentFamily, result, log = fmt.log.pl
     log(fmt.status('INFO', `Draft stats recorded: ${slug} stage=draft provider=${row.provider} model=${row.model} input_tokens=${row.input_tokens} tool_calls=${row.tool_calls}`));
   } catch (err) {
     // Best-effort: never escalate to the fatal `error` channel.
-    log(fmt.status('WARN', `Could not record draft stats for ${slug}: ${err.message}`));
+    log(fmt.status('WARN', `Could not record draft stats for ${slug}: ${/** @type {any} */ (err).message}`));
   }
 }