@juspay/shooter 1.12.0 → 1.14.0

package/.claude/hooks/notifier.cjs

@@ -261,7 +261,12 @@ function adaptClaudeCodeEvent(cliArg, stdinData) {
         return createCommonEvent('claude-code', 'permission_notification', data);
 
       case 'elicitation_dialog':
-        // Agent is presenting a question/dialog to the user
+        // Agent is presenting a question/dialog to the user. Forward
+        // choices/fields from stdin so extractElicitationChoices can
+        // surface CHOICE_N buttons (otherwise the question lands as a
+        // plain notification with no options).
+        if (Array.isArray(stdinData?.choices)) data.choices = stdinData.choices;
+        if (Array.isArray(stdinData?.fields)) data.fields = stdinData.fields;
         return createCommonEvent('claude-code', 'question', data);
 
       case 'idle_prompt':
@@ -284,6 +289,9 @@ function adaptClaudeCodeEvent(cliArg, stdinData) {
     data.tool = stdinData?.tool_name || process.env.CLAUDE_TOOL_NAME || 'Unknown';
     data.files = process.env.CLAUDE_FILE_PATHS || '';
     data.command = stdinData?.tool_input?.command || process.env.CLAUDE_COMMAND_LINE || '';
+    // tool_input is needed by handleAskUserQuestion to extract the
+    // question + options array. Forward it so handlers have access.
+    data.toolInput = stdinData?.tool_input || {};
     return createCommonEvent('claude-code', 'tool.before', data);
   }
 
@@ -513,6 +521,64 @@ async function processEvent(event) {
 
 function handleToolStart(event) {
   debugLog(`Tool starting: ${event.data.tool || 'unknown'}`);
+  // AskUserQuestion is a built-in tool whose answer we cannot intercept
+  // via any hook, but PreToolUse fires with the question + options in
+  // tool_input. Surface those on the phone (info-only) so the user can
+  // see what's being asked before walking back to the laptop.
+  if (event.data.tool === 'AskUserQuestion') {
+    handleAskUserQuestion(event);
+  }
+}
+
+/**
+ * Render an AskUserQuestion call as a rich, info-only notification.
+ *
+ * The hook can't intercept the answer (PreToolUse for non-permission
+ * tools is informational), so the iOS notification carries the
+ * question + options for awareness; the user picks at the laptop.
+ * Tapping an option button on the phone fires a POST to /api/response
+ * which the server records under responseKind='info' (no routing
+ * back to Claude Code in PR-3 — PTY routing is a follow-up).
+ */
+function handleAskUserQuestion(event) {
+  const d = event.data;
+  const toolInput = d.toolInput || {};
+  const extracted = extractAskUserQuestionOptions(toolInput);
+  if (!extracted) {
+    debugLog('AskUserQuestion did not yield extractable options — skipping');
+    return;
+  }
+
+  const category = categoryForOptionCount(extracted.options.length);
+  if (!category) {
+    debugLog(`AskUserQuestion option count outside lock-screen range — skipping`);
+    return;
+  }
+
+  const title = `${event.projectName} · Claude is asking`;
+  const subtitle = summarize(extracted.header || extracted.question, 70) || 'Awaiting answer';
+
+  const lines = [extracted.question || extracted.header || 'Choose an option:'];
+  const numbered = extracted.options.map((o, i) => `${i + 1}. ${o.label}`).join('   ');
+  lines.push('', numbered, '', 'Answer at your laptop.');
+  const body = lines.join('\n');
+
+  const requestId = Math.random().toString(36).substring(2, 15);
+
+  sendNotification(title, body, 'question', event.source, subtitle, {
+    notificationCategory: category,
+    options: extracted.options,
+    question: extracted.question,
+    requestId,
+    responseKind: 'info',
+    sessionId: d.sessionId,
+    toolInput,
+    toolName: 'AskUserQuestion',
+    // Need waitForResponse so /api/notify creates a pending_requests row
+    // (otherwise /api/decide/[id] won't find it when the user opens the
+    // Decide screen from the phone).
+    waitForResponse: true,
+  });
 }
 
 function handleToolEnd(event) {
@@ -523,19 +589,207 @@ function handleSessionStart(_event) {
   debugLog(`New session started: ${getSessionIdentifier()}`);
 }
 
+/**
+ * Plan-mode approval options surfaced when Claude calls ExitPlanMode.
+ *
+ * iOS shows the first 3 + Open-in-Shooter on the lock screen (4 button
+ * cap); plan_keep is reachable via the Decide screen.
+ */
+const PLAN_MODE_OPTIONS = [
+  { id: 'plan_auto', label: 'Auto Mode', hint: 'Bypass permissions for the rest of the session' },
+  {
+    id: 'plan_accept',
+    label: 'Accept Edits',
+    hint: 'Auto-accept file edits; still ask for risky operations',
+  },
+  { id: 'plan_review', label: 'Review Each', hint: 'Default — ask for each tool invocation' },
+  { id: 'plan_keep', label: 'Keep Planning', hint: 'Stay in plan mode without exiting' },
+];
+
+/**
+ * Map plan_* decisions to the hookSpecificOutput shape Claude Code's
+ * PermissionRequest hook expects:
+ *   plan_auto/accept/review → allow + updatedPermissions.setMode
+ *   plan_keep                → deny (stay in plan mode)
+ *
+ * Exported via test hook for unit testing without spinning up CC.
+ */
+function planDecisionToHookResponse(decision) {
+  const modeMap = {
+    plan_auto: 'bypassPermissions',
+    plan_accept: 'acceptEdits',
+    plan_review: 'default',
+  };
+  if (decision === 'plan_keep') {
+    return {
+      hookSpecificOutput: {
+        hookEventName: 'PermissionRequest',
+        permissionDecision: 'deny',
+        permissionDecisionReason: 'User chose to keep planning',
+      },
+    };
+  }
+  const mode = modeMap[decision];
+  if (!mode) return null;
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'PermissionRequest',
+      decision: {
+        behavior: 'allow',
+        updatedPermissions: [{ type: 'setMode', mode, destination: 'session' }],
+      },
+    },
+  };
+}
+
+/**
+ * Map a binary allow|deny decision to the hookSpecificOutput shape.
+ */
+function binaryDecisionToHookResponse(decision, wsActive) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'PermissionRequest',
+      permissionDecision: decision,
+      permissionDecisionReason: `User ${decision === 'allow' ? 'approved' : 'denied'} via ${wsActive ? 'WebSocket' : 'iPhone notification'}`,
+    },
+  };
+}
+
+/**
+ * Detect whether this permission request is the plan-mode approval
+ * (ExitPlanMode tool). Plan-mode gets a richer 4-option notification
+ * instead of binary allow/deny.
+ */
+function isPlanModePermission(d) {
+  return d.tool === 'ExitPlanMode' || d.toolName === 'ExitPlanMode';
+}
+
+/**
+ * Pick the right CHOICE_N notification category for an N-option push.
+ * Returns null when the count is outside the supported range (1 or
+ * >4) so the caller can fall back to info-only / open-in-app.
+ *
+ * iOS notification categories are pre-registered at app launch with
+ * fixed labels (see NotificationManager.swift); only counts 2/3/4 have
+ * dedicated registered categories.
+ */
+function categoryForOptionCount(n) {
+  if (n === 2) return 'CLAUDE_CHOICE_2';
+  if (n === 3) return 'CLAUDE_CHOICE_3';
+  if (n === 4) return 'CLAUDE_CHOICE_4';
+  return null;
+}
+
+/**
+ * Extract OptionChoice[] from AskUserQuestion's tool_input.
+ *
+ * AskUserQuestion's schema:
+ *   { questions: [{ question, header, multiSelect, options: [{label, description}] }] }
+ *
+ * Returns null when the tool_input doesn't look like a single-select
+ * multi-choice question with 2-4 options (the range we can render on
+ * iOS lock-screen buttons). The caller then falls through to the
+ * generic info notification.
+ */
+function extractAskUserQuestionOptions(toolInput) {
+  const questions = Array.isArray(toolInput?.questions) ? toolInput.questions : [];
+  if (questions.length === 0) return null;
+  const q = questions[0];
+  const rawOpts = Array.isArray(q?.options) ? q.options : [];
+  if (rawOpts.length < 2) return null;
+
+  // Cap at 4 — iOS lock-screen actions max out there. Anything beyond
+  // is reachable via the Decide screen which has no cap.
+  const trimmed = rawOpts.slice(0, 4);
+  const options = trimmed.map((o, i) => {
+    const label = typeof o?.label === 'string' && o.label.length > 0 ? o.label : `Option ${i + 1}`;
+    const hint =
+      typeof o?.description === 'string' && o.description.length > 0 ? o.description : undefined;
+    return hint ? { id: `option_${i + 1}`, label, hint } : { id: `option_${i + 1}`, label };
+  });
+
+  return {
+    options,
+    question: typeof q.question === 'string' ? q.question : '',
+    header: typeof q.header === 'string' ? q.header : '',
+  };
+}
+
+/**
+ * Extract choices from a Notification hook payload of type
+ * `elicitation_dialog`. MCP elicitation forms put a select field's
+ * choices in `fields[].choices` per the elicitation spec; some
+ * implementations also surface a flatter `choices` array directly on
+ * the notification data. We try both shapes.
+ *
+ * Returns null when no select-field with 2-4 choices is found.
+ */
+function extractElicitationChoices(data) {
+  const directChoices = Array.isArray(data?.choices) ? data.choices : null;
+  const fields = Array.isArray(data?.fields) ? data.fields : [];
+  const selectField = fields.find(
+    (f) => f && f.type === 'select' && Array.isArray(f.choices) && f.choices.length >= 2
+  );
+
+  const choices =
+    directChoices && directChoices.length >= 2 ? directChoices : (selectField?.choices ?? null);
+  if (!choices || choices.length < 2) return null;
+
+  const trimmed = choices.slice(0, 4);
+  const options = trimmed.map((c, i) => {
+    const label = typeof c === 'string' ? c : c?.label || c?.value || `Option ${i + 1}`;
+    return { id: `option_${i + 1}`, label };
+  });
+
+  return {
+    options,
+    fieldName: selectField?.name ?? null,
+  };
+}
+
+/**
+ * Build the notification body for a plan-mode approval. The plan
+ * content itself sits in body + question so the iOS Decide screen can
+ * show it; the body also lists the numbered options for lock-screen
+ * users who don't open the app.
+ */
+function buildPlanModeNotification(event) {
+  const d = event.data;
+  const toolInput = d.toolInput || {};
+  const plan = typeof toolInput.plan === 'string' ? toolInput.plan : '';
+  const planSummary = summarize(plan, 300) || 'Plan ready for approval';
+
+  const title = `${event.projectName} · Plan ready`;
+  const subtitle = summarize(plan, 70) || 'Review and choose how to proceed';
+  const body = [
+    planSummary,
+    '',
+    '1. Auto Mode  2. Accept Edits  3. Review Each  4. Keep Planning',
+  ].join('\n');
+
+  return { title, subtitle, body, question: plan };
+}
+
 /**
  * Handle permission events (agent needs user to approve a tool)
  *
  * Builds a rich notification with tool name + details when available,
  * falls back to the message text when tool details aren't available.
  * Content is identical between Claude Code and OpenCode.
+ *
+ * Plan-mode (ExitPlanMode tool) gets a special 4-option flow instead
+ * of binary allow/deny — see PLAN_MODE_OPTIONS + planDecisionToHookResponse.
  */
 async function handlePermission(event) {
   const d = event.data;
   debugLog(`Permission event: tool=${d.tool}, message=${d.message}`);
 
+  const planMode = isPlanModePermission(d);
+
   const ctx = getSessionContext(d.sessionId);
-  const { title, subtitle, body } = buildPermissionNotification(event, ctx);
+  const { title, subtitle, body } = planMode
+    ? buildPlanModeNotification(event)
+    : buildPermissionNotification(event, ctx);
 
   // Check if WebSocket clients are connected — if so, the events channel
   // will broadcast the permission-requested event and we skip the push notification
@@ -544,12 +798,20 @@ async function handlePermission(event) {
   // For Claude Code PermissionRequest: block and poll for iPhone response
   if (IS_CLAUDE_CODE && event.source === 'claude-code') {
     const requestId = Math.random().toString(36).substring(2, 15);
-    debugLog(`Starting bidirectional permission flow (requestId: ${requestId})`);
+    debugLog(
+      `Starting bidirectional permission flow (requestId: ${requestId}, planMode: ${planMode})`
+    );
+
+    const extras = { skipPush: wsActive, subtitle };
+    if (planMode) {
+      extras.notificationCategory = 'CLAUDE_PLAN_APPROVAL';
+      extras.options = PLAN_MODE_OPTIONS;
+      extras.question =
+        typeof d.toolInput?.plan === 'string' ? d.toolInput.plan : 'Approve plan and proceed?';
+      extras.responseKind = 'hook';
+    }
 
-    let result;
     if (wsActive) {
-      // WebSocket clients connected — skip push notification, but still register
-      // the pending request on the server so polling can find it.
       debugLog(`[Notifier] WebSocket clients connected, skipping push notification`);
       if (IS_CLAUDE_CODE) {
         console.error(`\n=== WEBSOCKET ACTIVE — SKIPPING PUSH [${requestId}] ===`);
@@ -557,42 +819,32 @@ async function handlePermission(event) {
         console.error(`Message: ${body}`);
         console.error(`=== REGISTERING REQUEST & POLLING VIA WEBSOCKET CHANNEL ===\n`);
       }
-
-      // Register the pending request but skip the actual push notification —
-      // the events channel will broadcast the permission to connected clients.
-      result = await sendNotificationAndPoll(
-        title,
-        body,
-        'permission',
-        event.source,
-        requestId,
-        d,
-        { skipPush: true, subtitle }
-      );
-    } else {
-      // No WebSocket clients — send push notification and poll
-      result = await sendNotificationAndPoll(
-        title,
-        body,
-        'permission',
-        event.source,
-        requestId,
-        d,
-        { subtitle }
-      );
     }
 
+    const result = await sendNotificationAndPoll(
+      title,
+      body,
+      'permission',
+      event.source,
+      requestId,
+      d,
+      extras
+    );
+
     if (result && result.decision) {
-      const hookResponse = {
-        hookSpecificOutput: {
-          hookEventName: 'PermissionRequest',
-          permissionDecision: result.decision,
-          permissionDecisionReason: `User ${result.decision === 'allow' ? 'approved' : 'denied'} via ${wsActive ? 'WebSocket' : 'iPhone notification'}`,
-        },
-      };
-      // Write decision to stdout for Claude Code to read
-      process.stdout.write(JSON.stringify(hookResponse));
-      debugLog(`Wrote hook decision to stdout: ${result.decision}`);
+      // Plan-mode decisions (plan_auto/accept/review/keep) need the
+      // richer hookSpecificOutput shape with updatedPermissions.setMode.
+      // Binary allow/deny falls through the legacy path.
+      const hookResponse = planMode
+        ? planDecisionToHookResponse(result.decision)
+        : binaryDecisionToHookResponse(result.decision, wsActive);
+
+      if (hookResponse) {
+        process.stdout.write(JSON.stringify(hookResponse));
+        debugLog(`Wrote hook decision to stdout: ${result.decision}`);
+      } else {
+        debugLog(`Unknown decision shape '${result.decision}' — falling through to local dialog`);
+      }
     } else {
       debugLog('No response received - falling through to local permission dialog');
       // Output nothing → Claude Code shows normal permission dialog
@@ -608,6 +860,11 @@ async function handlePermission(event) {
   }
 }
 
+// Pure helpers above are also re-exported alongside OpenCodePlugin at
+// the bottom of this file for unit testing. The single module.exports
+// block lives at the end of the file (see "Exports and Main Execution"
+// section).
+
 /**
  * Handle permission_notification events (Notification hook with permission_prompt type).
  *
@@ -644,7 +901,26 @@ function handleQuestion(event) {
   const ctx = getSessionContext(d.sessionId);
   const { title, subtitle, body } = buildQuestionNotification(event, ctx);
 
-  sendNotification(title, body, 'question', event.source, subtitle);
+  // If the elicitation payload has dynamic choices (MCP select field),
+  // surface them as a CHOICE_N category so the iOS Decide screen can
+  // render proper option buttons. Still info-only — the Notification
+  // hook can't return a decision, so any user tap on phone is recorded
+  // for awareness only.
+  const choiceData = extractElicitationChoices(d);
+  const extras = { sessionId: d.sessionId };
+  if (choiceData) {
+    const category = categoryForOptionCount(choiceData.options.length);
+    if (category) {
+      extras.notificationCategory = category;
+      extras.options = choiceData.options;
+      extras.question = d.message || d.title || '';
+      extras.responseKind = 'info';
+      extras.waitForResponse = true;
+      debugLog(`Elicitation choice surfaced: ${choiceData.options.length} options → ${category}`);
+    }
+  }
+
+  sendNotification(title, body, 'question', event.source, subtitle, extras);
 }
 
 /**
@@ -835,7 +1111,10 @@ function readSessionLines(sessionId, cwd) {
       const buf = Buffer.alloc(stat.size);
       fs.readSync(fd, buf, 0, stat.size, 0);
       fs.closeSync(fd);
-      const all = buf.toString('utf-8').split('\n').filter((l) => l.trim());
+      const all = buf
+        .toString('utf-8')
+        .split('\n')
+        .filter((l) => l.trim());
       firstLines = all;
       lastLines = all;
     } else {
@@ -846,9 +1125,15 @@ function readSessionLines(sessionId, cwd) {
       fs.readSync(fd, tailBuf, 0, tailSize, stat.size - tailSize);
       fs.closeSync(fd);
 
-      firstLines = headBuf.toString('utf-8').split('\n').filter((l) => l.trim());
+      firstLines = headBuf
+        .toString('utf-8')
+        .split('\n')
+        .filter((l) => l.trim());
       if (firstLines.length > 0) firstLines.pop(); // drop possibly-partial last line
-      lastLines = tailBuf.toString('utf-8').split('\n').filter((l) => l.trim());
+      lastLines = tailBuf
+        .toString('utf-8')
+        .split('\n')
+        .filter((l) => l.trim());
       if (lastLines.length > 0) lastLines.shift(); // drop possibly-partial first line
     }
 
@@ -1081,9 +1366,7 @@ function buildPermissionNotification(event, ctx = {}) {
   }
 
   // No tool name (Notification permission_prompt path).
-  const subtitle = goal
-    ? `Goal: ${summarize(goal, 70)}`
-    : summarize(message) || 'Permission';
+  const subtitle = goal ? `Goal: ${summarize(goal, 70)}` : summarize(message) || 'Permission';
 
   if (message) {
     const lines = [message];
@@ -1176,8 +1459,47 @@ function sendNotificationAndPoll(
   source,
   requestId,
   eventData,
-  { skipPush = false, subtitle = '' } = {}
+  {
+    skipPush = false,
+    subtitle = '',
+    // Dynamic-options extras forwarded to /api/notify body so the server
+    // can persist them on the pending_requests row + set the right APNs
+    // category. Undefined → server falls back to the binary CLAUDE_PERMISSION
+    // flow (preserves legacy behavior).
+    notificationCategory,
+    question,
+    options,
+    responseKind,
+  } = {}
 ) {
+  // Common body shared between the skipPush (register-only) and the
+  // full push paths. Splitting reduces drift between the two.
+  const buildNotifyBody = (timestamp, finalBody) => ({
+    title,
+    ...(subtitle ? { subtitle } : {}),
+    message: finalBody,
+    waitForResponse: true,
+    ...(skipPush ? { skipPush: true } : {}),
+    ...(DEVICE_TOKEN && { deviceToken: DEVICE_TOKEN }),
+    ...(notificationCategory && { notificationCategory }),
+    ...(question !== undefined && { question }),
+    ...(options && { options }),
+    ...(responseKind && { responseKind }),
+    data: {
+      category,
+      project: getProjectName(),
+      timestamp,
+      requestId,
+      clientTimestamp: timestamp,
+      source: 'shooter-completion-detector',
+      environment: USE_LOCAL ? 'local' : 'remote',
+      runtime: source,
+      toolName: eventData.tool || '',
+      toolInput: eventData.toolInput || {},
+      sessionId: eventData.sessionId || '',
+    },
+  });
+
   return new Promise((resolve) => {
     const timestamp = new Date().toISOString();
 
@@ -1194,27 +1516,7 @@ function sendNotificationAndPoll(
       // Register the pending request on the server so polling finds it.
       // We still need to POST with waitForResponse so the server creates
       // the pending-request entry, but we mark it as ws-only.
-      const registerPayload = JSON.stringify({
-        title,
-        ...(subtitle ? { subtitle } : {}),
-        message: finalBody,
-        waitForResponse: true,
-        skipPush: true,
-        ...(DEVICE_TOKEN && { deviceToken: DEVICE_TOKEN }),
-        data: {
-          category,
-          project: getProjectName(),
-          timestamp,
-          requestId,
-          clientTimestamp: timestamp,
-          source: 'shooter-completion-detector',
-          environment: USE_LOCAL ? 'local' : 'remote',
-          runtime: source,
-          toolName: eventData.tool || '',
-          toolInput: eventData.toolInput || {},
-          sessionId: eventData.sessionId || '',
-        },
-      });
+      const registerPayload = JSON.stringify(buildNotifyBody(timestamp, finalBody));
 
       const registerOptions = {
         method: 'POST',
@@ -1263,26 +1565,7 @@ function sendNotificationAndPoll(
 
     debugLog(`Sending bidirectional notification: "${title}" (requestId: ${requestId})`);
 
-    const payload = JSON.stringify({
-      title,
-      ...(subtitle ? { subtitle } : {}),
-      message: finalBody,
-      waitForResponse: true,
-      ...(DEVICE_TOKEN && { deviceToken: DEVICE_TOKEN }),
-      data: {
-        category,
-        project: getProjectName(),
-        timestamp,
-        requestId,
-        clientTimestamp: timestamp,
-        source: 'shooter-completion-detector',
-        environment: USE_LOCAL ? 'local' : 'remote',
-        runtime: source,
-        toolName: eventData.tool || '',
-        toolInput: eventData.toolInput || {},
-        sessionId: eventData.sessionId || '',
-      },
-    });
+    const payload = JSON.stringify(buildNotifyBody(timestamp, finalBody));
 
     const options = {
       method: 'POST',
@@ -1420,8 +1703,22 @@ function startPolling(requestId, resolve) {
   }, POLL_INTERVAL);
 }
 
-function sendNotification(title, body, category = 'completion', source = RUNTIME, subtitle = '') {
-  const requestId = Math.random().toString(36).substring(2, 15);
+function sendNotification(
+  title,
+  body,
+  category = 'completion',
+  source = RUNTIME,
+  subtitle = '',
+  // PR-3: extras carries the dynamic-options fields (notificationCategory,
+  // question, options, responseKind) for AskUserQuestion / elicitation
+  // pushes that need to render proper action buttons + populate the
+  // /api/decide/[id] payload. Optionally setting waitForResponse=true
+  // tells the server to persist a pending_requests row even though this
+  // is a fire-and-forget call (no polling) — needed so the iOS Decide
+  // screen can fetch the question + options afterward.
+  extras = {}
+) {
+  const requestId = extras.requestId || Math.random().toString(36).substring(2, 15);
   const timestamp = new Date().toISOString();
 
   // Title flows through unchanged; runtime/env metadata is appended as a low-weight
@@ -1437,6 +1734,11 @@ function sendNotification(title, body, category = 'completion', source = RUNTIME
     ...(subtitle ? { subtitle } : {}),
     message: finalBody,
     ...(DEVICE_TOKEN && { deviceToken: DEVICE_TOKEN }),
+    ...(extras.waitForResponse && { waitForResponse: true }),
+    ...(extras.notificationCategory && { notificationCategory: extras.notificationCategory }),
+    ...(extras.question !== undefined && { question: extras.question }),
+    ...(extras.options && { options: extras.options }),
+    ...(extras.responseKind && { responseKind: extras.responseKind }),
     data: {
       category,
       project: getProjectName(),
@@ -1446,6 +1748,12 @@ function sendNotification(title, body, category = 'completion', source = RUNTIME
       source: 'shooter-completion-detector',
       environment: USE_LOCAL ? 'local' : 'remote',
       runtime: source,
+      // Echo toolName/toolInput/sessionId when the caller knows them so
+      // the server-side row + Decide screen have full context (matches
+      // the eventData spread in sendNotificationAndPoll).
+      ...(extras.toolName && { toolName: extras.toolName }),
+      ...(extras.toolInput && { toolInput: extras.toolInput }),
+      ...(extras.sessionId && { sessionId: extras.sessionId }),
     },
   });
 
@@ -1643,11 +1951,26 @@ const OpenCodePlugin = async (ctx) => {
 // Exports and Main Execution
 // ============================================
 
-// Export for OpenCode plugin system
+// Export for OpenCode plugin system + unit tests.
+//
+// The default export remains OpenCodePlugin so the OpenCode plugin
+// loader (which does `require(notifier.cjs)()`) keeps working. Pure
+// helpers (plan-mode routing, etc.) are attached as named properties
+// so tests/ can require them without spawning the full hook script.
 if (typeof module !== 'undefined' && module.exports) {
   module.exports = OpenCodePlugin;
   module.exports.OpenCodePlugin = OpenCodePlugin;
   module.exports.ShooterNotifier = OpenCodePlugin;
+  // Pure-function exports for unit tests (tests/plan-mode-routing.test.cjs).
+  module.exports.PLAN_MODE_OPTIONS = PLAN_MODE_OPTIONS;
+  module.exports.binaryDecisionToHookResponse = binaryDecisionToHookResponse;
+  module.exports.isPlanModePermission = isPlanModePermission;
+  module.exports.planDecisionToHookResponse = planDecisionToHookResponse;
+  // PR-3 helpers (tests/dynamic-options-extraction.test.cjs).
+  module.exports.adaptClaudeCodeEvent = adaptClaudeCodeEvent;
+  module.exports.categoryForOptionCount = categoryForOptionCount;
+  module.exports.extractAskUserQuestionOptions = extractAskUserQuestionOptions;
+  module.exports.extractElicitationChoices = extractElicitationChoices;
 }
 
 // Run main() when called directly from CLI (Claude Code)

package/build/client/_app/immutable/chunks/{DfsJh23H.js → Bfg0k16X.js}

@@ -1 +1 @@
-import{s as e}from"./DlSs5Yra.js";const r=()=>{const s=e;return{page:{subscribe:s.page.subscribe},navigating:{subscribe:s.navigating.subscribe},updated:s.updated}},b={subscribe(s){return r().page.subscribe(s)}};export{b as p};
+import{s as e}from"./D8sAtVC-.js";const r=()=>{const s=e;return{page:{subscribe:s.page.subscribe},navigating:{subscribe:s.navigating.subscribe},updated:s.updated}},b={subscribe(s){return r().page.subscribe(s)}};export{b as p};

package/build/client/_app/immutable/chunks/{DTGtOxE1.js → CTchCNsn.js}

@@ -1 +1 @@
-import{s as r,p as e}from"./DlSs5Yra.js";const a={get params(){return e.params},get url(){return e.url}};r.updated.check;const s=a;export{s as p};
+import{s as r,p as e}from"./D8sAtVC-.js";const a={get params(){return e.params},get url(){return e.url}};r.updated.check;const s=a;export{s as p};