@scotthamilton77/sidekick 0.1.9 → 0.1.11

package/dist/bin.js

@@ -1098,6 +1098,7 @@ var require_events = __commonJS({
       "reminder:unstaged",
       "reminder:consumed",
       "reminder:cleared",
+      "reminder:not-staged",
       // Decision events
       "decision:recorded",
       // Session summary events
@@ -1146,6 +1147,7 @@ var require_events = __commonJS({
       "reminder:unstaged": "timeline",
       "reminder:consumed": "timeline",
       "reminder:cleared": "timeline",
+      "reminder:not-staged": "log",
       "decision:recorded": "timeline",
       "session-summary:start": "timeline",
       "session-summary:finish": "timeline",
@@ -45865,7 +45867,10 @@ var require_structured_logging = __commonJS({
             hookName: state.hookName,
             blocking: state.blocking,
             priority: state.priority,
-            persistent: state.persistent
+            persistent: state.persistent,
+            ...state.reason !== void 0 && { reason: state.reason },
+            ...state.triggeredBy !== void 0 && { triggeredBy: state.triggeredBy },
+            ...state.thresholdState !== void 0 && { thresholdState: state.thresholdState }
           }
         };
       },
@@ -46162,8 +46167,8 @@ var require_structured_logging = __commonJS({
       },
       // --- Error Events ---
       /**
-       * Create an ErrorOccurred event (logged when error/fatal level log is emitted).
-       * Emitted automatically by HookableLogger hook — no manual call-site changes needed.
+       * Create a daemon ErrorOccurred event.
+       * @see packages/sidekick-daemon/src/daemon.ts — HookableLogger error hook calls this factory.
        */
       daemonErrorOccurred(context, state) {
         return {
@@ -46182,6 +46187,28 @@ var require_structured_logging = __commonJS({
             errorStack: state.errorStack
           }
         };
+      },
+      /**
+       * Create a CLI ErrorOccurred event.
+       * Available for CLI error hook implementations.
+       */
+      cliErrorOccurred(context, state) {
+        return {
+          type: "error:occurred",
+          time: Date.now(),
+          source: "cli",
+          context: {
+            sessionId: context.sessionId,
+            correlationId: context.correlationId,
+            traceId: context.traceId,
+            hook: context.hook,
+            taskId: context.taskId
+          },
+          payload: {
+            errorMessage: state.errorMessage,
+            errorStack: state.errorStack
+          }
+        };
       }
     };
     function logEvent(logger, event) {
@@ -58137,24 +58164,20 @@ var require_staging_paths = __commonJS({
     function getReminderPath(stateDir, sessionId, hookName, reminderName) {
       return (0, node_path_1.join)(getHookDir(stateDir, sessionId, hookName), `${reminderName}.json`);
     }
-    function isValidPathSegment(segment) {
-      if (!segment)
+    function isValidPathSegment(s) {
+      if (s === "")
         return false;
-      if (segment.includes("..") || segment.includes("/") || segment.includes("\\"))
+      if (s === "." || s === "..")
         return false;
-      if (segment.startsWith("."))
+      if (s.includes("/") || s.includes("\\"))
         return false;
-      return true;
+      if ((0, node_path_1.basename)(s) !== s)
+        return false;
+      return /^[a-zA-Z0-9._-]+$/.test(s);
     }
     function validatePathSegment(segment, name) {
-      if (!segment) {
-        throw new Error(`${name} cannot be empty`);
-      }
-      if (segment.includes("..") || segment.includes("/") || segment.includes("\\")) {
-        throw new Error(`Invalid ${name}: path traversal characters not allowed`);
-      }
-      if (segment.startsWith(".")) {
-        throw new Error(`Invalid ${name}: cannot start with '.'`);
+      if (!isValidPathSegment(segment)) {
+        throw new Error(`Invalid ${name}: must be a non-empty alphanumeric string without path separators`);
       }
     }
     exports2.CONSUMED_FILE_PATTERN = /\.\d+\.json$/;
@@ -58228,7 +58251,7 @@ var require_staging_service = __commonJS({
        *
        * @throws Error if hookName or reminderName contain path traversal characters
        */
-      async stageReminder(sessionId, hookName, reminderName, data) {
+      async stageReminder(sessionId, hookName, reminderName, data, enrichment) {
         (0, staging_paths_js_1.validatePathSegment)(hookName, "hookName");
         (0, staging_paths_js_1.validatePathSegment)(reminderName, "reminderName");
         const hookDir = this.getHookDirPath(sessionId, hookName);
@@ -58257,9 +58280,10 @@ var require_staging_service = __commonJS({
           hookName,
           blocking: data.blocking,
           priority: data.priority,
-          persistent: data.persistent
+          persistent: data.persistent,
+          ...enrichment
         }, { stagingPath: reminderPath });
-        (0, structured_logging_1.logEvent)(this.options.logger, event);
+        (0, structured_logging_1.logEvent)(this.options.logger.child({ context: { sessionId } }), event);
       }
       /**
        * Read a staged reminder.
@@ -58401,8 +58425,8 @@ var require_staging_service = __commonJS({
       // ============================================================================
       // StagingService Interface Implementation (delegates to core)
       // ============================================================================
-      async stageReminder(hookName, reminderName, data) {
-        return this.core.stageReminder(this.sessionId, hookName, reminderName, data);
+      async stageReminder(hookName, reminderName, data, enrichment) {
+        return this.core.stageReminder(this.sessionId, hookName, reminderName, data, enrichment);
       }
       async readReminder(hookName, reminderName) {
         return this.core.readReminder(this.sessionId, hookName, reminderName);
@@ -71350,8 +71374,8 @@ var require_reminder_utils = __commonJS({
         return null;
       }
     }
-    async function stageReminder(ctx, hookName, reminder) {
-      await ctx.staging.stageReminder(hookName, reminder.name, reminder);
+    async function stageReminder(ctx, hookName, reminder, enrichment) {
+      await ctx.staging.stageReminder(hookName, reminder.name, reminder, enrichment);
       ctx.logger.debug("Staged reminder", { hookName, reminderName: reminder.name, priority: reminder.priority });
     }
     async function consumeReminder(ctx, hookName) {
@@ -71897,13 +71921,125 @@ var require_stage_default_user_prompt = __commonJS({
   }
 });
 
+// ../feature-reminders/dist/events.js
+var require_events2 = __commonJS({
+  "../feature-reminders/dist/events.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ReminderEvents = void 0;
+    exports2.ReminderEvents = {
+      /**
+       * Create a ReminderConsumed event (logged when CLI returns a staged reminder).
+       */
+      reminderConsumed(context, state, _metadata) {
+        return {
+          type: "reminder:consumed",
+          time: Date.now(),
+          source: "cli",
+          context: {
+            sessionId: context.sessionId,
+            correlationId: context.correlationId,
+            traceId: context.traceId,
+            hook: context.hook,
+            taskId: context.taskId
+          },
+          payload: {
+            reminderName: state.reminderName,
+            reminderReturned: state.reminderReturned,
+            blocking: state.blocking,
+            priority: state.priority,
+            persistent: state.persistent,
+            ...state.classificationResult !== void 0 && {
+              classificationResult: state.classificationResult
+            }
+          }
+        };
+      },
+      // Note: reminderStaged stays in @sidekick/core (used by staging-service.ts, circular dep)
+      /**
+       * Create a ReminderUnstaged event (logged when a reminder is removed from staging).
+       */
+      reminderUnstaged(context, state) {
+        return {
+          type: "reminder:unstaged",
+          time: Date.now(),
+          source: "daemon",
+          context: {
+            sessionId: context.sessionId,
+            correlationId: context.correlationId,
+            traceId: context.traceId,
+            hook: context.hook,
+            taskId: context.taskId
+          },
+          payload: {
+            reminderName: state.reminderName,
+            hookName: state.hookName,
+            reason: state.reason,
+            ...state.triggeredBy !== void 0 && { triggeredBy: state.triggeredBy },
+            ...state.toolState !== void 0 && { toolState: state.toolState }
+          }
+        };
+      },
+      /**
+       * Create a RemindersCleared event (logged when staging directory is cleaned).
+       */
+      remindersCleared(context, state, reason) {
+        return {
+          type: "reminder:cleared",
+          time: Date.now(),
+          source: "daemon",
+          context: {
+            sessionId: context.sessionId,
+            correlationId: context.correlationId,
+            traceId: context.traceId,
+            hook: context.hook,
+            taskId: context.taskId
+          },
+          payload: {
+            clearedCount: state.clearedCount,
+            hookNames: state.hookNames,
+            reason
+          }
+        };
+      },
+      /**
+       * Create a ReminderNotStaged event (logged when daemon evaluates but decides not to stage).
+       */
+      reminderNotStaged(context, state) {
+        return {
+          type: "reminder:not-staged",
+          time: Date.now(),
+          source: "daemon",
+          context: {
+            sessionId: context.sessionId,
+            correlationId: context.correlationId,
+            traceId: context.traceId,
+            hook: context.hook,
+            taskId: context.taskId
+          },
+          payload: {
+            reminderName: state.reminderName,
+            hookName: state.hookName,
+            reason: state.reason,
+            ...state.threshold !== void 0 && { threshold: state.threshold },
+            ...state.currentValue !== void 0 && { currentValue: state.currentValue },
+            ...state.triggeredBy !== void 0 && { triggeredBy: state.triggeredBy }
+          }
+        };
+      }
+    };
+  }
+});
+
 // ../feature-reminders/dist/handlers/staging/stage-pause-and-reflect.js
 var require_stage_pause_and_reflect = __commonJS({
   "../feature-reminders/dist/handlers/staging/stage-pause-and-reflect.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.registerStagePauseAndReflect = registerStagePauseAndReflect;
+    var core_1 = require_dist4();
     var types_1 = require_dist();
+    var events_js_1 = require_events2();
     var staging_handler_utils_js_1 = require_staging_handler_utils();
     var types_js_1 = require_types2();
     var state_js_1 = require_state4();
@@ -71917,15 +72053,17 @@ var require_stage_pause_and_reflect = __commonJS({
             return void 0;
           const metrics = event.metadata.metrics;
           const sessionId = event.context?.sessionId;
+          if (!sessionId) {
+            ctx.logger.warn("[stage-pause-and-reflect] No sessionId available, skipping");
+            return void 0;
+          }
           const featureConfig = context.config.getFeature("reminders");
           const config = { ...types_js_1.DEFAULT_REMINDERS_SETTINGS, ...featureConfig.settings };
           let prBaseline = null;
-          if (sessionId) {
-            const remindersState = (0, state_js_1.createRemindersState)(ctx.stateService);
-            const result = await remindersState.prBaseline.read(sessionId);
-            if (result.source !== "default") {
-              prBaseline = result.data;
-            }
+          const remindersState = (0, state_js_1.createRemindersState)(ctx.stateService);
+          const result = await remindersState.prBaseline.read(sessionId);
+          if (result.source !== "default") {
+            prBaseline = result.data;
           }
           let effectiveBaseline = 0;
           if (prBaseline && prBaseline.turnCount === metrics.turnCount) {
@@ -71937,12 +72075,28 @@ var require_stage_pause_and_reflect = __commonJS({
               effectiveBaseline = Math.max(effectiveBaseline, lastConsumed.stagedAt.toolsThisTurn);
             }
             const shouldReactivate = metrics.turnCount > lastConsumed.stagedAt.turnCount || metrics.toolsThisTurn >= effectiveBaseline + config.pause_and_reflect_threshold;
-            if (!shouldReactivate)
+            if (!shouldReactivate) {
+              (0, core_1.logEvent)(ctx.logger, events_js_1.ReminderEvents.reminderNotStaged({ sessionId }, {
+                reminderName: "pause-and-reflect",
+                hookName: "PreToolUse",
+                reason: "same_turn",
+                triggeredBy: "tool_result"
+              }));
               return void 0;
+            }
           }
           const toolsSinceBaseline = metrics.toolsThisTurn - effectiveBaseline;
-          if (toolsSinceBaseline < config.pause_and_reflect_threshold)
+          if (toolsSinceBaseline < config.pause_and_reflect_threshold) {
+            (0, core_1.logEvent)(ctx.logger, events_js_1.ReminderEvents.reminderNotStaged({ sessionId }, {
+              reminderName: "pause-and-reflect",
+              hookName: "PreToolUse",
+              reason: "below_threshold",
+              threshold: config.pause_and_reflect_threshold,
+              currentValue: toolsSinceBaseline,
+              triggeredBy: "tool_result"
+            }));
             return void 0;
+          }
           return {
             reminderId: types_js_1.ReminderIds.PAUSE_AND_REFLECT,
             targetHook: "PreToolUse",
@@ -73472,86 +73626,6 @@ var require_picomatch2 = __commonJS({
   }
 });
 
-// ../feature-reminders/dist/events.js
-var require_events2 = __commonJS({
-  "../feature-reminders/dist/events.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.ReminderEvents = void 0;
-    exports2.ReminderEvents = {
-      /**
-       * Create a ReminderConsumed event (logged when CLI returns a staged reminder).
-       */
-      reminderConsumed(context, state, _metadata) {
-        return {
-          type: "reminder:consumed",
-          time: Date.now(),
-          source: "cli",
-          context: {
-            sessionId: context.sessionId,
-            correlationId: context.correlationId,
-            traceId: context.traceId,
-            hook: context.hook,
-            taskId: context.taskId
-          },
-          payload: {
-            reminderName: state.reminderName,
-            reminderReturned: state.reminderReturned,
-            blocking: state.blocking,
-            priority: state.priority,
-            persistent: state.persistent
-          }
-        };
-      },
-      // Note: reminderStaged stays in @sidekick/core (used by staging-service.ts, circular dep)
-      /**
-       * Create a ReminderUnstaged event (logged when a reminder is removed from staging).
-       */
-      reminderUnstaged(context, state) {
-        return {
-          type: "reminder:unstaged",
-          time: Date.now(),
-          source: "daemon",
-          context: {
-            sessionId: context.sessionId,
-            correlationId: context.correlationId,
-            traceId: context.traceId,
-            hook: context.hook,
-            taskId: context.taskId
-          },
-          payload: {
-            reminderName: state.reminderName,
-            hookName: state.hookName,
-            reason: state.reason
-          }
-        };
-      },
-      /**
-       * Create a RemindersCleared event (logged when staging directory is cleaned).
-       */
-      remindersCleared(context, state, reason) {
-        return {
-          type: "reminder:cleared",
-          time: Date.now(),
-          source: "daemon",
-          context: {
-            sessionId: context.sessionId,
-            correlationId: context.correlationId,
-            traceId: context.traceId,
-            hook: context.hook,
-            taskId: context.taskId
-          },
-          payload: {
-            clearedCount: state.clearedCount,
-            hookNames: state.hookNames,
-            reason
-          }
-        };
-      }
-    };
-  }
-});
-
 // ../feature-reminders/dist/tool-pattern-matcher.js
 var require_tool_pattern_matcher = __commonJS({
   "../feature-reminders/dist/tool-pattern-matcher.js"(exports2) {
@@ -73659,22 +73733,48 @@ var require_track_verification_tools = __commonJS({
         }
       });
     }
-    async function stageToolsForFiles(filePaths, daemonCtx, sessionId, verificationTools, toolsState, remindersState) {
+    async function stageToolsForFiles(filePaths, daemonCtx, sessionId, verificationTools, toolsState, remindersState, triggeredBy = "file_edit") {
       const existingReminders = await daemonCtx.staging.listReminders("Stop");
       const stagedNames = new Set(existingReminders.map((r) => r.name));
       let anyStaged = false;
+      const emittedNotStaged = /* @__PURE__ */ new Set();
       for (const filePath of filePaths) {
         for (const [toolName, toolConfig] of Object.entries(verificationTools)) {
-          if (!toolConfig.enabled)
-            continue;
           const reminderId = TOOL_REMINDER_MAP[toolName];
           if (!reminderId)
             continue;
-          if (!picomatch_1.default.isMatch(filePath, toolConfig.clearing_patterns))
+          if (!toolConfig.enabled) {
+            const emitKey = `${reminderId}:feature_disabled`;
+            if (!emittedNotStaged.has(emitKey)) {
+              emittedNotStaged.add(emitKey);
+              (0, core_1.logEvent)(daemonCtx.logger, events_js_1.ReminderEvents.reminderNotStaged({ sessionId }, {
+                reminderName: reminderId,
+                hookName: "Stop",
+                reason: "feature_disabled",
+                triggeredBy
+              }));
+            }
+            continue;
+          }
+          if (!picomatch_1.default.isMatch(filePath, toolConfig.clearing_patterns)) {
+            const emitKey = `${reminderId}:pattern_mismatch`;
+            if (!emittedNotStaged.has(emitKey)) {
+              emittedNotStaged.add(emitKey);
+              (0, core_1.logEvent)(daemonCtx.logger, events_js_1.ReminderEvents.reminderNotStaged({ sessionId }, {
+                reminderName: reminderId,
+                hookName: "Stop",
+                reason: "pattern_mismatch",
+                triggeredBy
+              }));
+            }
             continue;
+          }
           const current = toolsState[toolName];
           if (!current || current.status === "staged") {
-            const staged = await ensureToolReminderStaged(daemonCtx, reminderId, stagedNames);
+            const staged = await ensureToolReminderStaged(daemonCtx, reminderId, stagedNames, {
+              reason: current ? "re-staged" : "initial",
+              triggeredBy: "file_edit"
+            });
             if (staged) {
               if (!current) {
                 toolsState[toolName] = {
@@ -73690,7 +73790,11 @@ var require_track_verification_tools = __commonJS({
           } else {
             const newEdits = current.editsSinceVerified + 1;
             if (newEdits >= toolConfig.clearing_threshold) {
-              const staged = await ensureToolReminderStaged(daemonCtx, reminderId, stagedNames);
+              const staged = await ensureToolReminderStaged(daemonCtx, reminderId, stagedNames, {
+                reason: "threshold_reached",
+                triggeredBy: "file_edit",
+                thresholdState: { current: newEdits, threshold: toolConfig.clearing_threshold }
+              });
               if (staged) {
                 toolsState[toolName] = {
                   ...current,
@@ -73707,6 +73811,14 @@ var require_track_verification_tools = __commonJS({
                 status: "cooldown",
                 editsSinceVerified: newEdits
               };
+              (0, core_1.logEvent)(daemonCtx.logger, events_js_1.ReminderEvents.reminderNotStaged({ sessionId }, {
+                reminderName: reminderId,
+                hookName: "Stop",
+                reason: "below_threshold",
+                threshold: toolConfig.clearing_threshold,
+                currentValue: newEdits,
+                triggeredBy
+              }));
             }
           }
         }
@@ -73752,7 +73864,16 @@ var require_track_verification_tools = __commonJS({
           lastMatchedScope: match.scope
         };
         await daemonCtx.staging.deleteReminder("Stop", reminderId);
-        (0, core_1.logEvent)(daemonCtx.logger, events_js_1.ReminderEvents.reminderUnstaged({ sessionId }, { reminderName: reminderId, hookName: "Stop", reason: "tool_verified" }));
+        (0, core_1.logEvent)(daemonCtx.logger, events_js_1.ReminderEvents.reminderUnstaged({ sessionId }, {
+          reminderName: reminderId,
+          hookName: "Stop",
+          reason: "tool_verified",
+          triggeredBy: "verification_passed",
+          toolState: {
+            status: toolsState[toolName].status,
+            editsSinceVerified: toolsState[toolName].editsSinceVerified
+          }
+        }));
         anyUnstaged = true;
         daemonCtx.logger.debug("VC tool verified", {
           toolName,
@@ -73767,13 +73888,18 @@ var require_track_verification_tools = __commonJS({
         const hasPerToolReminders = remaining.some((r) => VC_TOOL_NAME_SET.has(r.name));
         if (!hasPerToolReminders) {
           await daemonCtx.staging.deleteReminder("Stop", types_js_1.ReminderIds.VERIFY_COMPLETION);
-          (0, core_1.logEvent)(daemonCtx.logger, events_js_1.ReminderEvents.reminderUnstaged({ sessionId }, { reminderName: types_js_1.ReminderIds.VERIFY_COMPLETION, hookName: "Stop", reason: "all_tools_verified" }));
+          (0, core_1.logEvent)(daemonCtx.logger, events_js_1.ReminderEvents.reminderUnstaged({ sessionId }, {
+            reminderName: types_js_1.ReminderIds.VERIFY_COMPLETION,
+            hookName: "Stop",
+            reason: "all_tools_verified",
+            triggeredBy: "verification_passed"
+          }));
           daemonCtx.logger.info("All VC tools verified, unstaged wrapper", { sessionId });
         }
         await remindersState.verificationTools.write(sessionId, toolsState);
       }
     }
-    async function ensureToolReminderStaged(daemonCtx, reminderId, stagedNames) {
+    async function ensureToolReminderStaged(daemonCtx, reminderId, stagedNames, enrichment) {
       if (stagedNames.has(reminderId))
         return true;
       const reminder = (0, reminder_utils_js_1.resolveReminder)(reminderId, {
@@ -73787,7 +73913,7 @@ var require_track_verification_tools = __commonJS({
       await (0, reminder_utils_js_1.stageReminder)(daemonCtx, "Stop", {
         ...reminder,
         stagedAt: { timestamp: Date.now(), turnCount: 0, toolsThisTurn: 0, toolCount: 0 }
-      });
+      }, enrichment);
       return true;
     }
   }
@@ -73803,6 +73929,7 @@ var require_stage_stop_bash_changes = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.registerStageBashChanges = registerStageBashChanges;
     var core_1 = require_dist4();
+    var events_js_1 = require_events2();
     var types_1 = require_dist();
     var picomatch_1 = __importDefault2(require_picomatch2());
     var track_verification_tools_js_1 = require_track_verification_tools();
@@ -73872,6 +73999,12 @@ var require_stage_stop_bash_changes = __commonJS({
           if (lastConsumed?.stagedAt) {
             const shouldReactivate = metrics.turnCount > lastConsumed.stagedAt.turnCount;
             if (!shouldReactivate) {
+              (0, core_1.logEvent)(daemonCtx.logger, events_js_1.ReminderEvents.reminderNotStaged({ sessionId }, {
+                reminderName: "verify-completion",
+                hookName: "Stop",
+                reason: "same_turn",
+                triggeredBy: "bash_command"
+              }));
               daemonCtx.logger.debug("Bash VC: skipped (already consumed this turn)", {
                 currentTurn: metrics.turnCount,
                 lastConsumedTurn: lastConsumed.stagedAt.turnCount
@@ -73887,12 +74020,25 @@ var require_stage_stop_bash_changes = __commonJS({
             currentCount: current.length,
             newFileCount: newFiles.length
           });
-          if (newFiles.length === 0)
+          if (newFiles.length === 0) {
+            (0, core_1.logEvent)(daemonCtx.logger, events_js_1.ReminderEvents.reminderNotStaged({ sessionId }, {
+              reminderName: "verify-completion",
+              hookName: "Stop",
+              reason: "no_changes_detected",
+              triggeredBy: "bash_command"
+            }));
             return;
+          }
           const featureConfig = context.config.getFeature("reminders");
           const config = { ...types_js_1.DEFAULT_REMINDERS_SETTINGS, ...featureConfig.settings };
           const sourceMatches = newFiles.filter((f) => picomatch_1.default.isMatch(f, config.source_code_patterns));
           if (sourceMatches.length === 0) {
+            (0, core_1.logEvent)(daemonCtx.logger, events_js_1.ReminderEvents.reminderNotStaged({ sessionId }, {
+              reminderName: "verify-completion",
+              hookName: "Stop",
+              reason: "pattern_mismatch",
+              triggeredBy: "bash_command"
+            }));
             daemonCtx.logger.debug("Bash VC: new files found but no source code matches", { newFiles });
             return;
           }
@@ -73906,7 +74052,7 @@ var require_stage_stop_bash_changes = __commonJS({
           const remindersState = (0, state_js_1.createRemindersState)(daemonCtx.stateService);
           const stateResult = await remindersState.verificationTools.read(sessionId);
           const toolsState = { ...stateResult.data };
-          await (0, track_verification_tools_js_1.stageToolsForFiles)(sourceMatches, daemonCtx, sessionId, verificationTools, toolsState, remindersState);
+          await (0, track_verification_tools_js_1.stageToolsForFiles)(sourceMatches, daemonCtx, sessionId, verificationTools, toolsState, remindersState, "bash_command");
         }
       });
     }
@@ -74019,6 +74165,11 @@ var require_unstage_verify_completion = __commonJS({
               await remindersState.vcUnverified.delete(sessionId);
             }
           } else {
+            (0, core_1.logEvent)(daemonCtx.logger, events_js_1.ReminderEvents.reminderNotStaged({ sessionId }, {
+              reminderName: "verify-completion",
+              hookName: "Stop",
+              reason: "no_unverified_changes"
+            }));
             daemonCtx.logger.info("VC unstage: no unverified changes, clearing reminder", {
               sessionId,
               hadState: unverifiedState !== null
@@ -74028,7 +74179,12 @@ var require_unstage_verify_completion = __commonJS({
           const reason = unverifiedState?.hasUnverifiedChanges ? "cycle_limit_reached" : "no_unverified_changes";
           for (const vcId of types_js_1.ALL_VC_REMINDER_IDS) {
             await daemonCtx.staging.deleteReminder("Stop", vcId);
-            (0, core_1.logEvent)(daemonCtx.logger, events_js_1.ReminderEvents.reminderUnstaged(eventContext, { reminderName: vcId, hookName: "Stop", reason }));
+            (0, core_1.logEvent)(daemonCtx.logger, events_js_1.ReminderEvents.reminderUnstaged(eventContext, {
+              reminderName: vcId,
+              hookName: "Stop",
+              reason,
+              triggeredBy: unverifiedState?.hasUnverifiedChanges ? "cycle_limit" : "no_unverified_changes"
+            }));
           }
           daemonCtx.logger.debug("VC unstage: deleted all VC reminders");
         }
@@ -74126,12 +74282,22 @@ var require_stage_persona_reminders = __commonJS({
     }
     async function stagePersonaRemindersForSession(ctx, sessionId, options) {
       if (!isPersonaInjectionEnabled(ctx)) {
+        (0, core_1.logEvent)(ctx.logger, events_js_1.ReminderEvents.reminderNotStaged({ sessionId }, {
+          reminderName: "remember-your-persona",
+          hookName: "PreToolUse",
+          reason: "feature_disabled"
+        }));
         await clearPersonaReminders(ctx, sessionId);
         ctx.logger.debug("Persona injection disabled by config, cleaned up reminders", { sessionId });
         return;
       }
       const persona = await loadPersonaForSession(ctx, sessionId);
       if (!persona) {
+        (0, core_1.logEvent)(ctx.logger, events_js_1.ReminderEvents.reminderNotStaged({ sessionId }, {
+          reminderName: "remember-your-persona",
+          hookName: "PreToolUse",
+          reason: "no_persona"
+        }));
         await clearPersonaReminders(ctx, sessionId);
         ctx.logger.debug("Persona cleared or disabled, unstaged persona reminders", { sessionId });
         return;
@@ -74431,7 +74597,19 @@ var require_consumption_handler_factory = __commonJS({
               reader.renameReminder(hook, reminder.name);
             }
           }
-          let response = buildResponse ? await buildResponse({ reminder: primary, reader, cliCtx, sessionId, event, supportsBlocking }) : buildDefaultResponse(primary, supportsBlocking);
+          let enrichment;
+          let response;
+          if (buildResponse) {
+            const result = await buildResponse({ reminder: primary, reader, cliCtx, sessionId, event, supportsBlocking });
+            if ("response" in result && typeof result.response === "object") {
+              response = result.response;
+              enrichment = result.enrichment;
+            } else {
+              response = result;
+            }
+          } else {
+            response = buildDefaultResponse(primary, supportsBlocking);
+          }
           const secondaryContexts = reminders.slice(1).map((r) => r.additionalContext).filter((ctx2) => !!ctx2);
           if (secondaryContexts.length > 0) {
             const existing = response.additionalContext;
@@ -74449,7 +74627,8 @@ var require_consumption_handler_factory = __commonJS({
             reminderReturned: true,
             blocking: response.blocking ?? false,
             priority: primary.priority,
-            persistent: primary.persistent
+            persistent: primary.persistent,
+            ...enrichment
           }));
           return { response };
         }
@@ -74551,6 +74730,13 @@ var require_inject_stop = __commonJS({
               shouldBlock: classification.shouldBlock,
               reasoning: classification.reasoning?.slice(0, 200)
             });
+            const classificationEnrichment = {
+              classificationResult: {
+                category: classification.category,
+                confidence: classification.confidence,
+                shouldBlock: classification.shouldBlock
+              }
+            };
             if (classification.shouldBlock) {
               cliCtx.logger.info("VC inject-stop: BLOCKING (claiming completion)", { sessionId });
               try {
@@ -74560,7 +74746,10 @@ var require_inject_stop = __commonJS({
                   error: String(clearErr)
                 });
               }
-              return (0, consumption_handler_factory_js_1.buildDefaultResponse)(reminder, supportsBlocking);
+              return {
+                response: (0, consumption_handler_factory_js_1.buildDefaultResponse)(reminder, supportsBlocking),
+                enrichment: classificationEnrichment
+              };
             } else {
               cliCtx.logger.info("VC inject-stop: NOT BLOCKING", {
                 sessionId,
@@ -74586,13 +74775,13 @@ var require_inject_stop = __commonJS({
                 });
               }
               if (classification.category === "ASKING_QUESTION" || classification.category === "ANSWERING_QUESTION") {
-                return {};
+                return { response: {}, enrichment: classificationEnrichment };
               } else {
                 const response = {};
                 if (classification.userMessage) {
                   response.userMessage = classification.userMessage;
                 }
-                return response;
+                return { response, enrichment: classificationEnrichment };
               }
             }
           } catch (err) {
@@ -74963,7 +75152,8 @@ var require_orchestrator = __commonJS({
               (0, core_1.logEvent)(this.deps.logger, events_js_1.ReminderEvents.reminderUnstaged(eventContext, {
                 reminderName: vcId,
                 hookName: "Stop",
-                reason: "pause_and_reflect_cascade"
+                reason: "pause_and_reflect_cascade",
+                triggeredBy: "cascade_from_pause_and_reflect"
               }));
             }
             this.deps.logger.debug("Unstaged all VC reminders after P&R staged", { sessionId });
@@ -75000,7 +75190,12 @@ var require_orchestrator = __commonJS({
           try {
             const staging = this.deps.getStagingService(sessionId);
             await staging.deleteReminder("PreToolUse", types_js_1.ReminderIds.PAUSE_AND_REFLECT);
-            (0, core_1.logEvent)(this.deps.logger, events_js_1.ReminderEvents.reminderUnstaged({ sessionId }, { reminderName: types_js_1.ReminderIds.PAUSE_AND_REFLECT, hookName: "PreToolUse", reason: "vc_consumed_cascade" }));
+            (0, core_1.logEvent)(this.deps.logger, events_js_1.ReminderEvents.reminderUnstaged({ sessionId }, {
+              reminderName: types_js_1.ReminderIds.PAUSE_AND_REFLECT,
+              hookName: "PreToolUse",
+              reason: "vc_consumed_cascade",
+              triggeredBy: "cascade_from_verify_completion"
+            }));
             this.deps.logger.debug("Unstaged P&R after VC consumed", { sessionId });
           } catch (err) {
             this.deps.logger.warn("Failed to unstage P&R after VC consumed", {
@@ -83540,7 +83735,7 @@ var require_cli = __commonJS({
     var promises_12 = require("node:fs/promises");
     var node_stream_1 = require("node:stream");
     var yargs_parser_1 = __importDefault2(require_build());
-    var VERSION = true ? "0.1.9" : "dev";
+    var VERSION = true ? "0.1.11" : "dev";
     var SANDBOX_ERROR_MESSAGE = `Error: Daemon commands cannot run in sandbox mode.
 
 Claude Code's sandbox blocks Unix socket operations required for daemon IPC.