@magnusekdahl/parallix 1.1.0 → 1.2.0

package/lib/commands/handoff.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const { spawnSync } = require('child_process');
 const git = require('../core/git');
 const missionUtils = require('../core/mission-utils');
 const backlog = require('../tools/backlog');
@@ -11,16 +12,19 @@ const fmt = require('../core/fmt');
 const { runVerificationGate } = require('../core/verification');
 const { isForgejoReviewEnabled } = require('../core/product-config');
 const { rebaseBeforeReviewRound } = require('../review/rebase');
+const nels = require('../core/nels');
 
 /**
- * Verifies that the current environment is ready for handoff.
- *
- * @param {string} slug - Mission slug
- * @param {object} [options]
- * @returns {{ ok: boolean, error?: string, missionDir?: string, area?: string, branch?: string, rootDir?: string }}
- */
-function verifyHandoff(slug, options = {}) {
-  const rootDir = options.worktree || process.cwd();
+  * Verifies that the current environment is ready for handoff.
+  *
+  * @param {string} slug - Mission slug
+  * @param {{worktree?: string}} [options]
+  * @returns {{ ok: boolean, error?: string, missionDir?: string, area?: string, branch?: string, rootDir?: string }}
+  */
+ function verifyHandoff(slug, options = {}) {
+   /** @type{{worktree?: string}} */
+   const opts = options;
+   const rootDir = opts.worktree || process.cwd();
   const missionDir = missionUtils.findMissionDir(slug, rootDir);
   if (!missionDir) {
     return { ok: false, error: `Mission directory not found for slug: ${slug}` };
@@ -43,34 +47,38 @@ function verifyHandoff(slug, options = {}) {
 }
 
 /**
- * Performs the handoff process for a mission:
- * 1. Runs the verification gate.
- * 2. Syncs primary branch and pushes the mission branch to Forgejo, creating or updating the PR.
- * 3. Transitions Backlog task to 'review'.
- * 4. Commits and pushes the Backlog state change to Forgejo.
- *
- * @param {string} slug - Mission slug
- * @param {object} [options]
- * @returns {Promise<{ ok: boolean, error?: string }>}
- */
-async function performHandoff(slug, options = {}) {
-  const {
-    skipGate = false,
-    worktree = null,
-    force = false,
-    forceWithLease = true,
-    log = fmt.log.info,
-    error = fmt.log.fail,
-    rebaseFn = rebaseBeforeReviewRound
-  } = options;
-
-  const verification = verifyHandoff(slug, { worktree });
+  * Performs the handoff process for a mission:
+  * 1. Runs the verification gate.
+  * 2. Syncs primary branch and pushes the mission branch to Forgejo, creating or updating the PR.
+  * 3. Transitions Backlog task to 'review'.
+  * 4. Commits and pushes the Backlog state change to Forgejo.
+  *
+  * @param {string} slug - Mission slug
+  * @param {{skipGate?: boolean, worktree?: string|null, force?: boolean, forceWithLease?: boolean, log?: Function, error?: Function, rebaseFn?: Function, isForgejoReviewEnabledFn?: Function}} [options]
+  * @returns {Promise<{ ok: boolean, error?: string, gatekeeperPushedBack?: boolean }>}
+  */
+ async function performHandoff(slug, options = {}) {
+   /** @type{{skipGate?: boolean, worktree?: string|null, force?: boolean, forceWithLease?: boolean, log?: Function, error?: Function, rebaseFn?: Function, isForgejoReviewEnabledFn?: Function}} */
+   const opts = options;
+   const {
+     skipGate = false,
+     worktree = null,
+     force = false,
+     forceWithLease = true,
+     log = fmt.log.info,
+     error = fmt.log.fail,
+     rebaseFn = rebaseBeforeReviewRound
+   } = opts;
+
+   const verification = verifyHandoff(slug, { worktree: worktree || undefined });
   if (!verification.ok) {
     error(verification.error);
     return { ok: false, error: verification.error };
   }
 
-  const { area, branch, rootDir } = verification;
+  const { area, branch, missionDir } = verification;
+  const rootDir = /** @type {string} */(verification.rootDir);
+  const missionDirPath = /** @type {string} */(missionDir);
 
   // Step 0: Resolve Backlog task for identity derivation
   const taskResolution = backlog.resolveTaskFile(slug, rootDir);
@@ -81,9 +89,9 @@ async function performHandoff(slug, options = {}) {
   }
 
   // Pre-handoff Content Integrity Check
-  const relativeMissionPath = path.relative(rootDir, path.join(verification.missionDir, 'MISSION.md'));
+  const relativeMissionPath = path.relative(rootDir, path.join(missionDirPath, 'MISSION.md'));
   const dirtyFiles = git.getWorktreeStatus(rootDir);
-  let checkpoints = missionUtils.findCheckpoints(verification.missionDir);
+  let checkpoints = missionUtils.findCheckpoints(missionDirPath);
 
   if (dirtyFiles.some(line => line.endsWith(relativeMissionPath))) {
     const msg = `${fmt.path('MISSION.md')} is modified but uncommitted at ${fmt.path(relativeMissionPath)}. Commit the mission contract before handoff.`;
@@ -97,13 +105,13 @@ async function performHandoff(slug, options = {}) {
     // table so the handoff can proceed without manual intervention. The generated
     // file is clearly marked as auto-generated for reviewer awareness, then we
     // re-scan to confirm it is discoverable via findCheckpoints().
-    const autoCheckpointPath = path.join(verification.missionDir, 'CP-1.md');
+    const autoCheckpointPath = path.join(missionDirPath, 'CP-1.md');
     fs.writeFileSync(autoCheckpointPath, buildAutoCheckpointContent(slug), 'utf8');
-    log(fmt.status('WARN', `No checkpoint documents found — auto-generated ${fmt.path('CP-1.md')} in ${fmt.path(verification.missionDir)}.`));
+    log(fmt.status('WARN', `No checkpoint documents found — auto-generated ${fmt.path('CP-1.md')} in ${fmt.path(missionDirPath)}.`));
 
-    checkpoints = missionUtils.findCheckpoints(verification.missionDir);
+    checkpoints = missionUtils.findCheckpoints(missionDirPath);
     if (checkpoints.length === 0) {
-      const msg = `No checkpoint documents found in ${fmt.path(verification.missionDir)} even after auto-remediation. Implementation evidence is mandatory for review.`;
+      const msg = `No checkpoint documents found in ${fmt.path(missionDirPath)} even after auto-remediation. Implementation evidence is mandatory for review.`;
       error(msg);
       return { ok: false, error: msg };
     }
@@ -117,6 +125,7 @@ async function performHandoff(slug, options = {}) {
     }
   }
 
+  /** @type {string} */
   const finalCheckpoint = checkpoints[checkpoints.length - 1];
   const relativeCheckpointPath = path.relative(rootDir, finalCheckpoint);
   if (dirtyFiles.some(line => line.endsWith(relativeCheckpointPath))) {
@@ -140,7 +149,8 @@ async function performHandoff(slug, options = {}) {
   // Verify the goal-check table has at least one row of evidence (table row after header).
   // Must exclude table separator rows (|---|---|---|) and the header row itself —
   // only real evidence rows (with pipe-separated content that is not all dashes) count.
-  const afterHeader = checkpointContent.slice(goalCheckMatch.index + goalCheckMatch[0].length);
+  const goalCheckMatchIndex = goalCheckMatch.index ?? 0;
+  const afterHeader = checkpointContent.slice(goalCheckMatchIndex + goalCheckMatch[0].length);
   const separatorPattern = /^\|\s*:?-+:?\s*\|/;
   const headerPattern = /^\| .+\| .+\| .+\|$/;
   const evidenceLinePattern = /^\| .+\| .+\| .+\|$/;
@@ -149,12 +159,12 @@ async function performHandoff(slug, options = {}) {
   let pastHeader = false;
   for (const line of linesAfterHeader) {
     const trimmed = line.trim();
-    if (trimmed === '') continue;
+    if (trimmed === '') {continue;}
     if (!pastHeader && headerPattern.test(trimmed)) {
       pastHeader = true;
       continue;
     }
-    if (separatorPattern.test(trimmed)) continue;
+    if (separatorPattern.test(trimmed)) {continue;}
     if (pastHeader && evidenceLinePattern.test(trimmed)) {
       foundEvidence = true;
       break;
@@ -168,12 +178,12 @@ async function performHandoff(slug, options = {}) {
     return { ok: false, error: msg };
   }
 
-  const isForgejoReviewEnabledFn = options.isForgejoReviewEnabledFn || isForgejoReviewEnabled;
+  const isForgejoReviewEnabledFn = opts.isForgejoReviewEnabledFn || isForgejoReviewEnabled;
   const forgejoEnabled = isForgejoReviewEnabledFn(rootDir);
 
   const { forgejoUser: reviewStateUser } = resolveReviewIdentity(slug, rootDir, {
   });
-  const forgejoUser = reviewStateUser || backlog.getTaskImplementer(taskResolution.taskFile);
+  const forgejoUser = reviewStateUser || backlog.getTaskImplementer(/** @type {string} */(taskResolution.taskFile));
 
   if (!forgejoUser) {
     error('forgejoUser is required for performHandoff. Ensure review-state.json or the Backlog task has an agent family assigned.');
@@ -186,8 +196,8 @@ async function performHandoff(slug, options = {}) {
   if (skipGate) {
     fmt.log.warn('Step 1: Skipping final verification gate (--no-gate)');
   } else {
-    log(`Step 1: Running final verification gate for area: ${fmt.bold(area)}...`);
-    const verifyResult = runVerificationGate(area, {
+    log(`Step 1: Running final verification gate for area: ${fmt.bold(area || 'docs')}...`);
+    const verifyResult = runVerificationGate(area || 'docs', {
       rootDir,
       stdio: 'inherit',
       runFn: git.run
@@ -202,7 +212,7 @@ async function performHandoff(slug, options = {}) {
   // Step 1.5: Rebase mission branch onto latest primary before PR creation
   log('Step 1.5: Rebasing onto primary branch before handoff...');
   const rebaseResult = await rebaseFn(slug, {
-    worktree,
+    worktree: worktree || undefined,
     log,
     error,
     isForgejoReviewEnabledFn: isForgejoReviewEnabledFn,
@@ -219,9 +229,17 @@ async function performHandoff(slug, options = {}) {
     }
   }
 
+  // Step 1.7: NEL capture — compute actual NEL from merge diff and persist record
+  log('Step 1.7: Capturing Net Engineering Lines (NEL) at handoff...');
+  const nelResult = captureNelAtHandoff(slug, { rootDir, missionDir: missionDirPath, log, error });
+  if (nelResult.ok) {
+    log(fmt.status('PASS', `NEL captured: ${nelResult.nel} NEL (${nelResult.bucket.label} bucket)`));
+  } else {
+    log(fmt.status('WARN', `NEL capture skipped: ${nelResult.error}`));
+  }
+
   // Step 2: Forgejo PR Update/Create (optional mirror when Forgejo is enabled)
   let token = null;
-  let bootstrapUsed = false;
   let fallbackUser = null;
   let bootstrapFailureReason = null;
   if (forgejoEnabled) {
@@ -247,7 +265,6 @@ async function performHandoff(slug, options = {}) {
 
       if (bootstrapResult.ok) {
         log(fmt.status('PASS', `Bootstrap succeeded for ${fmt.agent(forgejoUser)}.`));
-        bootstrapUsed = true;
         token = forgejo.readToken(forgejoUser);
         if (!token) {
           bootstrapFailureReason = 'bootstrap completed but token file for the agent user was not found';
@@ -258,6 +275,10 @@ async function performHandoff(slug, options = {}) {
         error(`Bootstrap for ${fmt.agent(forgejoUser)} failed: ${bootstrapFailureReason}. Falling back to default user.`);
       }
 
+      // Handle bootstrap result that may not have error property
+      /** @type{{error?: string}} */
+      const br = bootstrapResult;
+
       // Magnus fallback if bootstrap didn't produce a token
       if (!token) {
         token = forgejo.readToken('human');
@@ -265,7 +286,7 @@ async function performHandoff(slug, options = {}) {
           fallbackUser = 'human';
           log(`Token not found for ${fmt.agent(forgejoUser)} and bootstrap did not succeed. Falling back to PR creation as ${fmt.agent(fallbackUser)}.`);
         } else {
-          const msg = `No Forgejo token found for user "${fmt.agent(forgejoUser)}", bootstrap failed (${bootstrapResult.error || 'unknown'}), and no fallback token available for "${fmt.agent('human')}". Manual action required: create a token manually or run \`node parallix setup-review\` first.`;
+          const msg = `No Forgejo token found for user "${fmt.agent(forgejoUser)}", bootstrap failed (${br.error || 'unknown'}), and no fallback token available for "${fmt.agent('human')}". Manual action required: create a token manually or run \`node parallix setup-review\` first.`;
           error(msg);
           return { ok: false, error: msg };
         }
@@ -281,7 +302,7 @@ async function performHandoff(slug, options = {}) {
       }
     }
 
-    const prResult = forgejo.createPr(branch, fallbackUser || forgejoUser, token, {
+    const prResult = forgejo.createPr(branch || '', String(fallbackUser || forgejoUser || 'default'), String(token || ''), {
       rootDir,
       log,
       forceWithLease
@@ -315,7 +336,21 @@ async function performHandoff(slug, options = {}) {
 
   if (gatekeeperPushedBack) {
     log(`Gatekeeper pushback posted for ${fmt.slug(slug)} — skipping Backlog transition to review.`);
-    return { ok: true, gatekeeperPushedBack: true };
+    return /** @type{{ok: boolean, gatekeeperPushedBack: boolean}} */({ ok: true, gatekeeperPushedBack: true });
+  }
+
+  // Step 2.6: Generic ## Gates runner — execute any gates declared in MISSION.md
+  log('Step 2.6: Running declared gates from MISSION.md...');
+  const gatesResult = runDeclaredGates(verification.missionDir || '', rootDir, { log, error });
+  if (!gatesResult.ok) {
+    const msg = `Declared gate "${gatesResult.gate}" failed for ${fmt.slug(slug)}: ${gatesResult.error || gatesResult.reason}. Blocking handoff — task remains in active.`;
+    error(msg);
+    return { ok: false, error: msg };
+  }
+  if (gatesResult.skipped) {
+    log(`No declared gates for ${fmt.slug(slug)} (${gatesResult.reason}).`);
+  } else {
+    log(`All ${gatesResult.count} declared gate(s) passed for ${fmt.slug(slug)}.`);
   }
 
   // Step 3 & 4: Backlog Transition and Commit
@@ -346,24 +381,24 @@ async function performHandoff(slug, options = {}) {
         error(`${msg}${fetchError ? ` ${fetchError}` : ''}`);
         return { ok: false, error: msg };
       }
-      const tracking = forgejo.resolveTrackingBranchSha(branch, rootDir);
+      const tracking = forgejo.resolveTrackingBranchSha(branch || '', rootDir);
       if (!tracking.ok) {
         const msg = `Failed to resolve Backlog transition lease for ${fmt.slug(slug)} before Forgejo push.`;
         error(msg);
         return { ok: false, error: `${msg} ${tracking.error || ''}`.trim() };
       }
-      pushLeaseArg = `--force-with-lease=refs/heads/${branch}:${tracking.sha}`;
+      pushLeaseArg = `--force-with-lease=refs/heads/${branch}:${String(tracking.sha || '')}`;
     }
     const pushArgs = ['-C', rootDir, 'push'];
     if (pushLeaseArg) {
       pushArgs.push(pushLeaseArg);
     }
-    pushArgs.push(remoteUrl, branch);
+    pushArgs.push(String(remoteUrl || ''), branch || '');
     const pushBacklogForgejo = git.git(pushArgs);
     if (pushBacklogForgejo.status !== 0) {
       const pushError = [pushBacklogForgejo.stderr, pushBacklogForgejo.stdout].filter(Boolean).join('\n');
       if (force && /non-fast-forward|stale info|fetch first/i.test(pushError || '')) {
-        const forceArgs = ['-C', rootDir, 'push', '--force', remoteUrl, branch];
+        const forceArgs = ['-C', rootDir, 'push', '--force', String(remoteUrl || ''), branch || ''];
         const forceResult = git.git(forceArgs);
         if (forceResult.status === 0) {
           fmt.log.info(`Backlog transition for ${fmt.slug(slug)} required plain force after stale lease.`);
@@ -382,7 +417,66 @@ async function performHandoff(slug, options = {}) {
   }
 
   fmt.log.pass(`Mission ${fmt.slug(slug)} handed off successfully.`);
-  return { ok: true, gatekeeperPushedBack };
+  return /** @type{{ok: boolean, gatekeeperPushedBack?: boolean}} */({ ok: true, gatekeeperPushedBack });
+}
+
+/**
+ * Parse and execute declared gates from a mission's MISSION.md `## Gates` section.
+ * Each gate line is treated as a shell command to be executed via spawnSync.
+ * Returns { ok, skipped, count, reason } on success or { ok: false, gate, error, reason } on failure.
+ */
+/** @param {string} missionDir @param {string} rootDir @param {{log?: Function, error?: Function}} [options] */
+function runDeclaredGates(missionDir, rootDir, options = {}) {
+  const { log = fmt.log.plain } = /** @type {{log?: Function, error?: Function}} */ (options);
+  const missionPath = path.join(missionDir, 'MISSION.md');
+  if (!fs.existsSync(missionPath)) {
+    return { ok: true, skipped: true, reason: 'no-mission-file' };
+  }
+
+  const content = fs.readFileSync(missionPath, 'utf8');
+
+  // Extract the ## Gates section
+  const gatesSectionMatch = content.match(/^## Gates\s*\n([\s\S]*?)(?=\n## |\n$)/m);
+  if (!gatesSectionMatch) {
+    return { ok: true, skipped: true, reason: 'no-gates-section' };
+  }
+
+  const gatesBlock = gatesSectionMatch[1];
+  const gateLines = gatesBlock.split('\n')
+    .map(line => line.trim())
+    .filter(line => line.startsWith('- [ ]') || line.startsWith('- [x]') || line.startsWith('- '));
+
+  // Strip the checkbox prefix to get the command
+  const commands = gateLines.map(line => {
+    // Remove "- [ ] ", "- [x] ", or "- " prefix
+    return line.replace(/^- \[[ x]\]\s*/, '').replace(/^- \s*/, '');
+  }).filter(cmd => cmd.length > 0);
+
+  if (commands.length === 0) {
+    return { ok: true, skipped: true, reason: 'no-gates-declared' };
+  }
+
+  // Execute each gate command
+  for (const cmd of commands) {
+    log(`  Gate: ${cmd}`);
+    const result = spawnSync('bash', ['-c', cmd], {
+      cwd: rootDir,
+      encoding: 'utf8',
+      stdio: ['inherit', 'pipe', 'pipe']
+    });
+
+    if (result.status !== 0) {
+      const stderr = (result.stderr || '').trim();
+      return {
+        ok: false,
+        gate: cmd,
+        reason: 'gate-failed',
+        error: stderr || `Gate exited with status ${result.status}`
+      };
+    }
+  }
+
+  return { ok: true, skipped: false, count: commands.length, reason: 'all-gates-passed' };
 }
 
 /**
@@ -419,16 +513,19 @@ function buildAutoCheckpointContent(slug) {
 }
 
 /**
- * Write a fallback summary (`## Fallback:` heading) into the backlog task file.
- * This is the in-scope equivalent of backlog.setTaskFinalSummary, implemented
- * inline here since modifying backlog.js is out of scope for this mission.
- * @param {string} slug - Mission slug
- * @param {string} summary - The fallback summary text (must contain ## Fallback)
- * @param {object} options
- * @returns {boolean}
- */
-function writeFallbackSummary(slug, summary, options = {}) {
-  const { rootDir = process.cwd(), log = fmt.log.plain } = options;
+  * Write a fallback summary (`## Fallback:` heading) into the backlog task file.
+  * This is the in-scope equivalent of backlog.setTaskFinalSummary, implemented
+  * inline here since modifying backlog.js is out of scope for this mission.
+  * @param {string} slug - Mission slug
+  * @param {string} summary - The fallback summary text (must contain ## Fallback)
+  * @param {{rootDir?: string, log?: Function}} options
+  * @returns {boolean}
+  */
+ function writeFallbackSummary(slug, summary, options = {}) {
+   /** @type{{rootDir?: string, log?: Function}} */
+   const opts = options;
+   const rootDir = opts.rootDir || process.cwd();
+   const log = opts.log || fmt.log.plain;
   const resolution = backlog.resolveTaskFile(slug, rootDir);
   if (!resolution.ok) {
     log(fmt.status('WARN', `Could not write fallback summary for ${fmt.slug(slug)}: ${resolution.reason}`));
@@ -436,6 +533,11 @@ function writeFallbackSummary(slug, summary, options = {}) {
   }
 
   const taskFile = resolution.taskFile;
+  if (!taskFile) {
+    log(fmt.status('WARN', `Could not write fallback summary for ${fmt.slug(slug)}: task file not found.`));
+    return false;
+  }
+  /** @type{string} */
   let content = fs.readFileSync(taskFile, 'utf8');
 
   // Already present — no-op
@@ -478,6 +580,90 @@ function writeFallbackSummary(slug, summary, options = {}) {
   return true;
 }
 
+/**
+ * Capture NEL (Net Engineering Lines) at handoff time.
+ *
+ * Computes actual NEL from the merge diff (primary..HEAD), reads the predicted
+ * bucket from the mission's Refinement Signals, resolves review rounds from
+ * review-state.json, and persists a per-mission NEL record as `nel-record.json`.
+ *
+ * This is purely observational — no enforcement, gates, or blocks.
+ *
+ * @param {string} slug - Mission slug
+ * @param {{ rootDir: string, missionDir: string, log: Function, error: Function }} options
+ * @returns {{ ok: boolean, nel?: number, bucket?: string, error?: string }}
+ */
+function captureNelAtHandoff(slug, options) {
+   const { rootDir, missionDir, error } = options;
+
+  // 1. Determine primary branch for diff range
+  let primaryBranch;
+  try {
+    primaryBranch = missionUtils.getPrimaryBranch(rootDir);
+  } catch (_) {
+    return { ok: false, error: 'could not detect primary branch for NEL diff range' };
+  }
+
+  if (!primaryBranch) {
+    return { ok: false, error: 'primary branch is empty' };
+  }
+
+  // 2. Compute actual NEL from primary..HEAD
+  let nelRecord;
+  try {
+    nelRecord = nels.computeNELRecord(`${primaryBranch}..HEAD`, { cwd: rootDir });
+  } catch (_) {
+    return { ok: false, error: 'NEL computation failed' };
+  }
+
+  const actualNel = nelRecord.nel;
+  const actualBucket = nelRecord.bucket.label;
+
+  // 3. Read predicted bucket from MISSION.md Refinement Signals
+  const missionMdPath = path.join(missionDir, 'MISSION.md');
+  let predictedBucket = 'Unknown';
+  if (fs.existsSync(missionMdPath)) {
+    const content = fs.readFileSync(missionMdPath, 'utf8');
+    const predictedMatch = content.match(/Predicted NEL bucket:\s*(Small|Medium|Large)/i);
+    if (predictedMatch) {
+      predictedBucket = predictedMatch[1];
+    }
+  }
+
+  // 4. Read review rounds from review-state.json
+  let reviewRounds = 1;
+  const reviewStatePath = path.join(missionDir, 'review-state.json');
+  if (fs.existsSync(reviewStatePath)) {
+    try {
+      const rs = JSON.parse(fs.readFileSync(reviewStatePath, 'utf8'));
+      reviewRounds = rs.round || 1;
+    } catch (_) {
+      // ignore parse errors
+    }
+  }
+
+  // 5. Persist NEL record
+  const nelRecordPath = path.join(missionDir, 'nel-record.json');
+  const record = {
+    slug,
+    predictedBucket,
+    actualNel,
+    actualBucket,
+    reviewRounds,
+    capturedAt: new Date().toISOString(),
+  };
+
+  try {
+    fs.writeFileSync(nelRecordPath, JSON.stringify(record, null, 2) + '\n', 'utf8');
+  } catch (err) {
+    error(`Failed to write NEL record: ${err.message}`);
+    return { ok: false, error: `failed to write NEL record: ${err.message}` };
+  }
+
+  return { ok: true, nel: actualNel, bucket: actualBucket };
+}
+
+/** @param {string[]} args */
 async function handoffCommand(args) {
   const explicitSlug = args[0];
   const slug = missionUtils.inferSlug(explicitSlug);
@@ -499,3 +685,5 @@ module.exports = handoffCommand;
 module.exports.verifyHandoff = verifyHandoff;
 module.exports.performHandoff = performHandoff;
 module.exports.gatekeeper = gatekeeper;
+module.exports.runDeclaredGates = runDeclaredGates;
+module.exports.captureNelAtHandoff = captureNelAtHandoff;