@scotthamilton77/sidekick 0.1.3 → 0.1.5

package/dist/bin.js

@@ -17213,7 +17213,7 @@ var require_state = __commonJS({
   "../types/dist/services/state.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.DEFAULT_LATENCY_STATS = exports2.LLMMetricsStateSchema = exports2.LLMSessionTotalsSchema = exports2.LLMProviderMetricsSchema = exports2.LLMModelMetricsSchema = exports2.LLMLatencyStatsSchema = exports2.DEFAULT_PROJECT_METRICS = exports2.DEFAULT_BASE_METRICS = exports2.SessionContextMetricsSchema = exports2.ProjectContextMetricsSchema = exports2.BaseTokenMetricsStateSchema = exports2.VCUnverifiedStateSchema = exports2.PRBaselineStateSchema = exports2.EMPTY_LOG_METRICS = exports2.LogMetricsStateSchema = exports2.TranscriptMetricsStateSchema = exports2.ResumeMessageStateSchema = exports2.SnarkyMessageStateSchema = exports2.SummaryCountdownStateSchema = exports2.LastStagedPersonaSchema = exports2.SessionPersonaStateSchema = exports2.SESSION_SUMMARY_PLACEHOLDERS = exports2.SessionSummaryStateSchema = void 0;
+    exports2.DEFAULT_LATENCY_STATS = exports2.LLMMetricsStateSchema = exports2.LLMSessionTotalsSchema = exports2.LLMProviderMetricsSchema = exports2.LLMModelMetricsSchema = exports2.LLMLatencyStatsSchema = exports2.DEFAULT_PROJECT_METRICS = exports2.DEFAULT_BASE_METRICS = exports2.SessionContextMetricsSchema = exports2.ProjectContextMetricsSchema = exports2.BaseTokenMetricsStateSchema = exports2.UPSThrottleStateSchema = exports2.VerificationToolsStateSchema = exports2.VerificationToolStatusSchema = exports2.VCUnverifiedStateSchema = exports2.PRBaselineStateSchema = exports2.EMPTY_LOG_METRICS = exports2.LogMetricsStateSchema = exports2.TranscriptMetricsStateSchema = exports2.ResumeMessageStateSchema = exports2.SnarkyMessageStateSchema = exports2.SummaryCountdownStateSchema = exports2.LastStagedPersonaSchema = exports2.SessionPersonaStateSchema = exports2.SESSION_SUMMARY_PLACEHOLDERS = exports2.SessionSummaryStateSchema = void 0;
     exports2.createDefaultLLMMetrics = createDefaultLLMMetrics;
     var zod_1 = require_zod();
     exports2.SessionSummaryStateSchema = zod_1.z.object({
@@ -17362,6 +17362,25 @@ var require_state = __commonJS({
         confidence: zod_1.z.number()
       })
     });
+    exports2.VerificationToolStatusSchema = zod_1.z.object({
+      /** Current state: staged (needs run), verified (recently run), cooldown (post-verified, counting edits) */
+      status: zod_1.z.enum(["staged", "verified", "cooldown"]),
+      /** Number of qualifying file edits since last verification */
+      editsSinceVerified: zod_1.z.number(),
+      /** Unix timestamp (ms) when last verified, null if never */
+      lastVerifiedAt: zod_1.z.number().nullable(),
+      /** Unix timestamp (ms) when last staged, null if never */
+      lastStagedAt: zod_1.z.number().nullable(),
+      /** tool_id of the pattern that last matched (metadata for future scope-aware logic) */
+      lastMatchedToolId: zod_1.z.string().nullable().optional(),
+      /** Scope of the last matched pattern */
+      lastMatchedScope: zod_1.z.enum(["project", "package", "file"]).nullable().optional()
+    });
+    exports2.VerificationToolsStateSchema = zod_1.z.record(zod_1.z.string(), exports2.VerificationToolStatusSchema);
+    exports2.UPSThrottleStateSchema = zod_1.z.object({
+      /** Number of conversation messages since the reminder was last staged */
+      messagesSinceLastStaging: zod_1.z.number()
+    });
     exports2.BaseTokenMetricsStateSchema = zod_1.z.object({
       /** System prompt tokens (~3.2k) */
       systemPromptTokens: zod_1.z.number(),
@@ -45250,7 +45269,10 @@ var require_structured_logging = __commonJS({
           mkdir: true
         }).then((stream) => {
           this.realStream = stream;
-          this.drainPending((chunk, cb) => stream.write(chunk, cb));
+          this.drainPending((chunk, cb) => {
+            stream.write(chunk);
+            cb();
+          });
         }).catch((err) => {
           process.stderr.write(`[sidekick] pino-roll init failed, using appendFileSync fallback: ${err}
 `);
@@ -45259,7 +45281,8 @@ var require_structured_logging = __commonJS({
       }
       _write(chunk, _encoding, callback) {
         if (this.realStream) {
-          this.realStream.write(chunk, callback);
+          this.realStream.write(chunk);
+          callback();
         } else if (this.initPending) {
           this.pending.push({ chunk, callback });
         } else {
@@ -71078,7 +71101,154 @@ var require_types2 = __commonJS({
   "../feature-reminders/dist/types.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.ReminderIds = exports2.DEFAULT_REMINDERS_SETTINGS = exports2.DEFAULT_COMPLETION_DETECTION_SETTINGS = exports2.DEFAULT_SOURCE_CODE_PATTERNS = void 0;
+    exports2.ALL_VC_REMINDER_IDS = exports2.VC_TOOL_REMINDER_IDS = exports2.ReminderIds = exports2.DEFAULT_REMINDERS_SETTINGS = exports2.DEFAULT_COMPLETION_DETECTION_SETTINGS = exports2.DEFAULT_SOURCE_CODE_PATTERNS = exports2.DEFAULT_VERIFICATION_TOOLS = exports2.VerificationToolsMapSchema = exports2.VerificationToolConfigSchema = exports2.ToolPatternSchema = exports2.ToolPatternScopeSchema = void 0;
+    var zod_1 = require_zod2();
+    exports2.ToolPatternScopeSchema = zod_1.z.enum(["project", "package", "file"]);
+    exports2.ToolPatternSchema = zod_1.z.object({
+      tool_id: zod_1.z.string(),
+      tool: zod_1.z.string().nullable(),
+      scope: exports2.ToolPatternScopeSchema.default("project")
+    });
+    exports2.VerificationToolConfigSchema = zod_1.z.object({
+      enabled: zod_1.z.boolean(),
+      patterns: zod_1.z.array(exports2.ToolPatternSchema).min(1),
+      clearing_threshold: zod_1.z.number().int().positive(),
+      clearing_patterns: zod_1.z.array(zod_1.z.string()).min(1)
+    });
+    exports2.VerificationToolsMapSchema = zod_1.z.record(zod_1.z.string(), exports2.VerificationToolConfigSchema);
+    exports2.DEFAULT_VERIFICATION_TOOLS = {
+      build: {
+        enabled: true,
+        patterns: [
+          // TypeScript/JavaScript
+          { tool_id: "tsc", tool: "tsc", scope: "project" },
+          { tool_id: "esbuild", tool: "esbuild", scope: "file" },
+          { tool_id: "pnpm-filter-build", tool: "pnpm --filter * build", scope: "package" },
+          { tool_id: "pnpm-build", tool: "pnpm build", scope: "project" },
+          { tool_id: "npm-build", tool: "npm run build", scope: "project" },
+          { tool_id: "yarn-workspace-build", tool: "yarn workspace * build", scope: "package" },
+          { tool_id: "yarn-build", tool: "yarn build", scope: "project" },
+          // Python
+          { tool_id: "python-setup-build", tool: "python setup.py build", scope: "project" },
+          { tool_id: "pip-install", tool: "pip install", scope: "project" },
+          { tool_id: "poetry-build", tool: "poetry build", scope: "project" },
+          // JVM
+          { tool_id: "mvn-compile", tool: "mvn compile", scope: "project" },
+          { tool_id: "mvn-package", tool: "mvn package", scope: "project" },
+          { tool_id: "gradle-build", tool: "gradle build", scope: "project" },
+          { tool_id: "gradlew-build", tool: "./gradlew build", scope: "project" },
+          // Go
+          { tool_id: "go-build", tool: "go build", scope: "project" },
+          // Rust
+          { tool_id: "cargo-build", tool: "cargo build", scope: "project" },
+          // C/C++
+          { tool_id: "make-build", tool: "make build", scope: "project" },
+          { tool_id: "make-default", tool: "make", scope: "project" },
+          { tool_id: "cmake-build", tool: "cmake --build", scope: "project" },
+          // Containers
+          { tool_id: "docker-build", tool: "docker build", scope: "project" }
+        ],
+        clearing_threshold: 3,
+        clearing_patterns: [
+          "**/*.ts",
+          "**/*.tsx",
+          "**/*.js",
+          "**/*.jsx",
+          "**/*.py",
+          "**/*.java",
+          "**/*.kt",
+          "**/*.go",
+          "**/*.rs",
+          "**/*.c",
+          "**/*.cpp",
+          "**/*.cs"
+        ]
+      },
+      typecheck: {
+        enabled: true,
+        patterns: [
+          { tool_id: "tsc-noEmit", tool: "tsc --noEmit", scope: "project" },
+          { tool_id: "pnpm-filter-typecheck", tool: "pnpm --filter * typecheck", scope: "package" },
+          { tool_id: "pnpm-typecheck", tool: "pnpm typecheck", scope: "project" },
+          { tool_id: "npm-typecheck", tool: "npm run typecheck", scope: "project" },
+          { tool_id: "yarn-workspace-typecheck", tool: "yarn workspace * typecheck", scope: "package" },
+          { tool_id: "yarn-typecheck", tool: "yarn typecheck", scope: "project" },
+          { tool_id: "mypy", tool: "mypy", scope: "project" },
+          { tool_id: "pyright", tool: "pyright", scope: "project" },
+          { tool_id: "pytype", tool: "pytype", scope: "project" },
+          { tool_id: "go-vet", tool: "go vet", scope: "project" }
+        ],
+        clearing_threshold: 3,
+        clearing_patterns: ["**/*.ts", "**/*.tsx", "**/*.py", "**/*.go"]
+      },
+      test: {
+        enabled: true,
+        patterns: [
+          { tool_id: "vitest", tool: "vitest", scope: "project" },
+          { tool_id: "jest", tool: "jest", scope: "project" },
+          { tool_id: "pnpm-filter-test", tool: "pnpm --filter * test", scope: "package" },
+          { tool_id: "pnpm-test", tool: "pnpm test", scope: "project" },
+          { tool_id: "npm-test", tool: "npm test", scope: "project" },
+          { tool_id: "yarn-workspace-test", tool: "yarn workspace * test", scope: "package" },
+          { tool_id: "yarn-test", tool: "yarn test", scope: "project" },
+          { tool_id: "pytest", tool: "pytest", scope: "project" },
+          { tool_id: "python-pytest", tool: "python -m pytest", scope: "project" },
+          { tool_id: "python-unittest", tool: "python -m unittest", scope: "project" },
+          { tool_id: "mvn-test", tool: "mvn test", scope: "project" },
+          { tool_id: "gradle-test", tool: "gradle test", scope: "project" },
+          { tool_id: "gradlew-test", tool: "./gradlew test", scope: "project" },
+          { tool_id: "go-test", tool: "go test", scope: "project" },
+          { tool_id: "cargo-test", tool: "cargo test", scope: "project" },
+          { tool_id: "dotnet-test", tool: "dotnet test", scope: "project" },
+          { tool_id: "make-test", tool: "make test", scope: "project" }
+        ],
+        clearing_threshold: 3,
+        clearing_patterns: [
+          "**/*.ts",
+          "**/*.tsx",
+          "**/*.js",
+          "**/*.jsx",
+          "**/*.py",
+          "**/*.java",
+          "**/*.kt",
+          "**/*.go",
+          "**/*.rs",
+          "**/*.test.*",
+          "**/*.spec.*",
+          "**/test_*"
+        ]
+      },
+      lint: {
+        enabled: true,
+        patterns: [
+          { tool_id: "eslint", tool: "eslint", scope: "project" },
+          { tool_id: "pnpm-filter-lint", tool: "pnpm --filter * lint", scope: "package" },
+          { tool_id: "pnpm-lint", tool: "pnpm lint", scope: "project" },
+          { tool_id: "npm-lint", tool: "npm run lint", scope: "project" },
+          { tool_id: "yarn-workspace-lint", tool: "yarn workspace * lint", scope: "package" },
+          { tool_id: "yarn-lint", tool: "yarn lint", scope: "project" },
+          { tool_id: "ruff", tool: "ruff", scope: "project" },
+          { tool_id: "flake8", tool: "flake8", scope: "project" },
+          { tool_id: "pylint", tool: "pylint", scope: "project" },
+          { tool_id: "golangci-lint", tool: "golangci-lint", scope: "project" },
+          { tool_id: "cargo-clippy", tool: "cargo clippy", scope: "project" },
+          { tool_id: "ktlint", tool: "ktlint", scope: "project" },
+          { tool_id: "dotnet-format", tool: "dotnet format", scope: "project" }
+        ],
+        clearing_threshold: 5,
+        clearing_patterns: [
+          "**/*.ts",
+          "**/*.tsx",
+          "**/*.js",
+          "**/*.jsx",
+          "**/*.py",
+          "**/*.java",
+          "**/*.kt",
+          "**/*.go",
+          "**/*.rs"
+        ]
+      }
+    };
     exports2.DEFAULT_SOURCE_CODE_PATTERNS = [
       // TypeScript/JavaScript
       "**/*.ts",
@@ -71128,17 +71298,65 @@ var require_types2 = __commonJS({
     exports2.DEFAULT_REMINDERS_SETTINGS = {
       pause_and_reflect_threshold: 60,
       source_code_patterns: exports2.DEFAULT_SOURCE_CODE_PATTERNS,
-      max_verification_cycles: -1
+      max_verification_cycles: -1,
       // -1 = unlimited, 0 = disabled
+      verification_tools: exports2.DEFAULT_VERIFICATION_TOOLS,
+      user_prompt_submit_threshold: 10
     };
     exports2.ReminderIds = {
       USER_PROMPT_SUBMIT: "user-prompt-submit",
       PAUSE_AND_REFLECT: "pause-and-reflect",
       VERIFY_COMPLETION: "verify-completion",
+      VC_BUILD: "vc-build",
+      VC_TYPECHECK: "vc-typecheck",
+      VC_TEST: "vc-test",
+      VC_LINT: "vc-lint",
       REMEMBER_YOUR_PERSONA: "remember-your-persona",
       PERSONA_CHANGED: "persona-changed",
       USER_PROFILE: "user-profile"
     };
+    exports2.VC_TOOL_REMINDER_IDS = [
+      exports2.ReminderIds.VC_BUILD,
+      exports2.ReminderIds.VC_TYPECHECK,
+      exports2.ReminderIds.VC_TEST,
+      exports2.ReminderIds.VC_LINT
+    ];
+    exports2.ALL_VC_REMINDER_IDS = [exports2.ReminderIds.VERIFY_COMPLETION, ...exports2.VC_TOOL_REMINDER_IDS];
+  }
+});
+
+// ../feature-reminders/dist/state.js
+var require_state3 = __commonJS({
+  "../feature-reminders/dist/state.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createRemindersState = createRemindersState;
+    var core_1 = require_dist4();
+    var types_1 = require_dist();
+    var PRBaselineDescriptor = (0, core_1.sessionState)("pr-baseline.json", types_1.PRBaselineStateSchema, {
+      defaultValue: null,
+      trackHistory: true
+    });
+    var VCUnverifiedDescriptor = (0, core_1.sessionState)("vc-unverified.json", types_1.VCUnverifiedStateSchema, {
+      defaultValue: null,
+      trackHistory: true
+    });
+    var VerificationToolsDescriptor = (0, core_1.sessionState)("verification-tools.json", types_1.VerificationToolsStateSchema, {
+      defaultValue: {},
+      trackHistory: false
+    });
+    var UPSThrottleDescriptor = (0, core_1.sessionState)("ups-throttle.json", types_1.UPSThrottleStateSchema, {
+      defaultValue: { messagesSinceLastStaging: 0 },
+      trackHistory: false
+    });
+    function createRemindersState(stateService) {
+      return {
+        prBaseline: new core_1.SessionStateAccessor(stateService, PRBaselineDescriptor),
+        vcUnverified: new core_1.SessionStateAccessor(stateService, VCUnverifiedDescriptor),
+        verificationTools: new core_1.SessionStateAccessor(stateService, VerificationToolsDescriptor),
+        upsThrottle: new core_1.SessionStateAccessor(stateService, UPSThrottleDescriptor)
+      };
+    }
   }
 });
 
@@ -71151,6 +71369,8 @@ var require_stage_default_user_prompt = __commonJS({
     var types_1 = require_dist();
     var staging_handler_utils_js_1 = require_staging_handler_utils();
     var types_js_1 = require_types2();
+    var reminder_utils_js_1 = require_reminder_utils();
+    var state_js_1 = require_state3();
     function registerStageDefaultUserPrompt(context) {
       (0, staging_handler_utils_js_1.createStagingHandler)(context, {
         id: "reminders:stage-default-user-prompt",
@@ -71168,6 +71388,23 @@ var require_stage_default_user_prompt = __commonJS({
           };
         }
       });
+      if ((0, types_1.isDaemonContext)(context)) {
+        const startCtx = context;
+        context.handlers.register({
+          id: "reminders:ups-throttle-reset-session-start",
+          priority: 49,
+          filter: { kind: "hook", hooks: ["SessionStart"] },
+          handler: async (event) => {
+            if (!(0, types_1.isHookEvent)(event) || !(0, types_1.isSessionStartEvent)(event))
+              return;
+            const sessionId = event.context.sessionId;
+            if (!sessionId)
+              return;
+            const remindersState = (0, state_js_1.createRemindersState)(startCtx.stateService);
+            await remindersState.upsThrottle.write(sessionId, { messagesSinceLastStaging: 0 });
+          }
+        });
+      }
       (0, staging_handler_utils_js_1.createStagingHandler)(context, {
         id: "reminders:stage-default-user-prompt-after-bulk",
         priority: 50,
@@ -71184,31 +71421,68 @@ var require_stage_default_user_prompt = __commonJS({
           };
         }
       });
-    }
-  }
-});
-
-// ../feature-reminders/dist/state.js
-var require_state3 = __commonJS({
-  "../feature-reminders/dist/state.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.createRemindersState = createRemindersState;
-    var core_1 = require_dist4();
-    var types_1 = require_dist();
-    var PRBaselineDescriptor = (0, core_1.sessionState)("pr-baseline.json", types_1.PRBaselineStateSchema, {
-      defaultValue: null,
-      trackHistory: true
-    });
-    var VCUnverifiedDescriptor = (0, core_1.sessionState)("vc-unverified.json", types_1.VCUnverifiedStateSchema, {
-      defaultValue: null,
-      trackHistory: true
-    });
-    function createRemindersState(stateService) {
-      return {
-        prBaseline: new core_1.SessionStateAccessor(stateService, PRBaselineDescriptor),
-        vcUnverified: new core_1.SessionStateAccessor(stateService, VCUnverifiedDescriptor)
-      };
+      if ((0, types_1.isDaemonContext)(context)) {
+        const bulkCtx = context;
+        context.handlers.register({
+          id: "reminders:ups-throttle-reset-bulk",
+          priority: 49,
+          filter: { kind: "transcript", eventTypes: ["BulkProcessingComplete"] },
+          handler: async (event) => {
+            if (!(0, types_1.isTranscriptEvent)(event))
+              return;
+            if (event.metadata.isBulkProcessing)
+              return;
+            const sessionId = event.context?.sessionId;
+            if (!sessionId)
+              return;
+            const remindersState = (0, state_js_1.createRemindersState)(bulkCtx.stateService);
+            await remindersState.upsThrottle.write(sessionId, { messagesSinceLastStaging: 0 });
+          }
+        });
+      }
+      if (!(0, types_1.isDaemonContext)(context))
+        return;
+      context.handlers.register({
+        id: "reminders:ups-throttle-restage",
+        priority: 50,
+        filter: { kind: "transcript", eventTypes: ["UserPrompt", "AssistantMessage"] },
+        handler: async (event, ctx) => {
+          if (!(0, types_1.isTranscriptEvent)(event))
+            return;
+          if (!(0, types_1.isDaemonContext)(ctx))
+            return;
+          if (event.metadata.isBulkProcessing)
+            return;
+          const sessionId = event.context?.sessionId;
+          if (!sessionId)
+            return;
+          const handlerCtx = ctx;
+          const remindersState = (0, state_js_1.createRemindersState)(handlerCtx.stateService);
+          const result = await remindersState.upsThrottle.read(sessionId);
+          const current = result.data.messagesSinceLastStaging;
+          const featureConfig = handlerCtx.config.getFeature("reminders");
+          const config = { ...types_js_1.DEFAULT_REMINDERS_SETTINGS, ...featureConfig.settings };
+          const threshold = config.user_prompt_submit_threshold ?? 10;
+          const newCount = current + 1;
+          if (newCount >= threshold) {
+            const reminder = (0, reminder_utils_js_1.resolveReminder)(types_js_1.ReminderIds.USER_PROMPT_SUBMIT, {
+              context: { sessionId },
+              assets: handlerCtx.assets
+            });
+            if (reminder) {
+              await (0, reminder_utils_js_1.stageReminder)(handlerCtx, "UserPromptSubmit", reminder);
+              handlerCtx.logger.debug("UPS throttle: re-staged reminder", {
+                sessionId,
+                messageCount: newCount,
+                threshold
+              });
+            }
+            await remindersState.upsThrottle.write(sessionId, { messagesSinceLastStaging: 0 });
+          } else {
+            await remindersState.upsThrottle.write(sessionId, { messagesSinceLastStaging: newCount });
+          }
+        }
+      });
     }
   }
 });
@@ -72788,73 +73062,228 @@ var require_picomatch2 = __commonJS({
   }
 });
 
-// ../feature-reminders/dist/handlers/staging/stage-stop-reminders.js
-var require_stage_stop_reminders = __commonJS({
-  "../feature-reminders/dist/handlers/staging/stage-stop-reminders.js"(exports2) {
+// ../feature-reminders/dist/tool-pattern-matcher.js
+var require_tool_pattern_matcher = __commonJS({
+  "../feature-reminders/dist/tool-pattern-matcher.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.matchesToolPattern = matchesToolPattern;
+    exports2.findMatchingPattern = findMatchingPattern;
+    var SHELL_OPERATOR_RE = /\s*(?:&&|\|\||[;|])\s*/;
+    function matchesToolPattern(command, pattern) {
+      if (!command || !pattern)
+        return false;
+      const segments = command.split(SHELL_OPERATOR_RE);
+      const patternTokens = pattern.trim().split(/\s+/).filter(Boolean);
+      if (patternTokens.length === 0)
+        return false;
+      return segments.some((segment) => {
+        const cmdTokens = segment.trim().split(/\s+/);
+        if (cmdTokens.length === 0 || cmdTokens[0] === "")
+          return false;
+        if (cmdTokens[0] !== patternTokens[0])
+          return false;
+        let pi = 1;
+        for (let ci = 1; ci < cmdTokens.length && pi < patternTokens.length; ci++) {
+          if (patternTokens[pi] === "*" || patternTokens[pi] === cmdTokens[ci]) {
+            pi++;
+          }
+        }
+        return pi === patternTokens.length;
+      });
+    }
+    function findMatchingPattern(command, patterns) {
+      for (const pattern of patterns) {
+        if (pattern.tool === null)
+          continue;
+        if (matchesToolPattern(command, pattern.tool))
+          return pattern;
+      }
+      return null;
+    }
+  }
+});
+
+// ../feature-reminders/dist/handlers/staging/track-verification-tools.js
+var require_track_verification_tools = __commonJS({
+  "../feature-reminders/dist/handlers/staging/track-verification-tools.js"(exports2) {
     "use strict";
     var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.registerStageStopReminders = registerStageStopReminders;
+    exports2.registerTrackVerificationTools = registerTrackVerificationTools;
+    exports2.stageToolsForFiles = stageToolsForFiles;
     var types_1 = require_dist();
     var picomatch_1 = __importDefault2(require_picomatch2());
-    var staging_handler_utils_js_1 = require_staging_handler_utils();
+    var tool_pattern_matcher_js_1 = require_tool_pattern_matcher();
+    var reminder_utils_js_1 = require_reminder_utils();
     var types_js_1 = require_types2();
+    var state_js_1 = require_state3();
     var FILE_EDIT_TOOLS = ["Write", "Edit", "MultiEdit"];
-    function registerStageStopReminders(context) {
-      (0, staging_handler_utils_js_1.createStagingHandler)(context, {
-        id: "reminders:stage-stop-reminders",
+    var TOOL_REMINDER_MAP = {
+      build: types_js_1.ReminderIds.VC_BUILD,
+      typecheck: types_js_1.ReminderIds.VC_TYPECHECK,
+      test: types_js_1.ReminderIds.VC_TEST,
+      lint: types_js_1.ReminderIds.VC_LINT
+    };
+    var VC_TOOL_NAME_SET = new Set(types_js_1.VC_TOOL_REMINDER_IDS);
+    function extractToolInput(event) {
+      const entry = event.payload.entry;
+      return entry?.input;
+    }
+    function registerTrackVerificationTools(context) {
+      if (!(0, types_1.isDaemonContext)(context))
+        return;
+      context.handlers.register({
+        id: "reminders:track-verification-tools",
         priority: 60,
         filter: { kind: "transcript", eventTypes: ["ToolCall"] },
-        execute: async (event, ctx) => {
+        handler: async (event, ctx) => {
           if (!(0, types_1.isTranscriptEvent)(event))
-            return void 0;
+            return;
+          if (event.metadata.isBulkProcessing)
+            return;
+          if (!(0, types_1.isDaemonContext)(ctx))
+            return;
+          const daemonCtx = ctx;
+          const sessionId = event.context?.sessionId;
+          if (!sessionId)
+            return;
           const toolName = event.payload.toolName;
-          if (!toolName || !FILE_EDIT_TOOLS.includes(toolName))
-            return void 0;
+          if (!toolName)
+            return;
           const featureConfig = context.config.getFeature("reminders");
           const config = { ...types_js_1.DEFAULT_REMINDERS_SETTINGS, ...featureConfig.settings };
-          const entry = event.payload.entry;
-          const filePath = entry?.input?.file_path;
-          if (!filePath)
-            return void 0;
-          const isMatch = picomatch_1.default.isMatch(filePath, config.source_code_patterns);
-          if (!isMatch) {
-            ctx.logger.debug("VC staging: file edit skipped (no pattern match)", {
-              toolName,
-              filePath
-            });
-            return void 0;
+          const verificationTools = config.verification_tools ?? {};
+          const remindersState = (0, state_js_1.createRemindersState)(daemonCtx.stateService);
+          const stateResult = await remindersState.verificationTools.read(sessionId);
+          const toolsState = { ...stateResult.data };
+          if (FILE_EDIT_TOOLS.includes(toolName)) {
+            await handleFileEdit(event, daemonCtx, sessionId, verificationTools, toolsState, remindersState);
+          } else if (toolName === "Bash") {
+            await handleBashCommand(event, daemonCtx, sessionId, verificationTools, toolsState, remindersState);
           }
-          const metrics = event.metadata.metrics;
-          const lastConsumed = await ctx.staging.getLastConsumed("Stop", types_js_1.ReminderIds.VERIFY_COMPLETION);
-          if (lastConsumed?.stagedAt) {
-            const shouldReactivate = metrics.turnCount > lastConsumed.stagedAt.turnCount;
-            if (!shouldReactivate) {
-              ctx.logger.debug("VC staging: skipped (already consumed this turn)", {
-                currentTurn: metrics.turnCount,
-                lastConsumedTurn: lastConsumed.stagedAt.turnCount
-              });
-              return void 0;
+        }
+      });
+    }
+    async function stageToolsForFiles(filePaths, daemonCtx, sessionId, verificationTools, toolsState, remindersState) {
+      const existingReminders = await daemonCtx.staging.listReminders("Stop");
+      const stagedNames = new Set(existingReminders.map((r) => r.name));
+      let anyStaged = false;
+      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))
+            continue;
+          const current = toolsState[toolName];
+          if (!current || current.status === "staged") {
+            if (!current) {
+              toolsState[toolName] = {
+                status: "staged",
+                editsSinceVerified: 0,
+                lastVerifiedAt: null,
+                lastStagedAt: Date.now()
+              };
+            }
+            await stageToolReminderIfNeeded(daemonCtx, reminderId, stagedNames);
+            anyStaged = true;
+          } else {
+            const newEdits = current.editsSinceVerified + 1;
+            if (newEdits >= toolConfig.clearing_threshold) {
+              toolsState[toolName] = {
+                ...current,
+                status: "staged",
+                editsSinceVerified: 0,
+                lastStagedAt: Date.now()
+              };
+              await stageToolReminderIfNeeded(daemonCtx, reminderId, stagedNames);
+              anyStaged = true;
+            } else {
+              toolsState[toolName] = {
+                ...current,
+                status: "cooldown",
+                editsSinceVerified: newEdits
+              };
             }
-            ctx.logger.info("VC staging: reactivating on new turn", {
-              currentTurn: metrics.turnCount,
-              lastConsumedTurn: lastConsumed.stagedAt.turnCount
-            });
           }
-          ctx.logger.info("VC staging: staging verify-completion", {
-            toolName,
-            filePath,
-            turnCount: metrics.turnCount,
-            toolCount: metrics.toolCount,
-            firstTimeThisSession: !lastConsumed
-          });
-          return {
-            reminderId: types_js_1.ReminderIds.VERIFY_COMPLETION,
-            targetHook: "Stop"
-          };
         }
+      }
+      if (anyStaged) {
+        await stageToolReminderIfNeeded(daemonCtx, types_js_1.ReminderIds.VERIFY_COMPLETION, stagedNames);
+      }
+      await remindersState.verificationTools.write(sessionId, toolsState);
+      return anyStaged;
+    }
+    async function handleFileEdit(event, daemonCtx, sessionId, verificationTools, toolsState, remindersState) {
+      const filePath = extractToolInput(event)?.file_path;
+      if (!filePath)
+        return;
+      const projectDir = daemonCtx.paths?.projectDir;
+      if (projectDir && !filePath.startsWith(projectDir))
+        return;
+      await stageToolsForFiles([filePath], daemonCtx, sessionId, verificationTools, toolsState, remindersState);
+    }
+    async function handleBashCommand(event, daemonCtx, sessionId, verificationTools, toolsState, remindersState) {
+      const command = extractToolInput(event)?.command;
+      if (!command)
+        return;
+      let anyUnstaged = false;
+      for (const [toolName, toolConfig] of Object.entries(verificationTools)) {
+        if (!toolConfig.enabled)
+          continue;
+        const reminderId = TOOL_REMINDER_MAP[toolName];
+        if (!reminderId)
+          continue;
+        const match = (0, tool_pattern_matcher_js_1.findMatchingPattern)(command, toolConfig.patterns);
+        if (!match)
+          continue;
+        toolsState[toolName] = {
+          status: "verified",
+          editsSinceVerified: 0,
+          lastVerifiedAt: Date.now(),
+          lastStagedAt: toolsState[toolName]?.lastStagedAt ?? null,
+          lastMatchedToolId: match.tool_id,
+          lastMatchedScope: match.scope
+        };
+        await daemonCtx.staging.deleteReminder("Stop", reminderId);
+        anyUnstaged = true;
+        daemonCtx.logger.debug("VC tool verified", {
+          toolName,
+          reminderId,
+          matchedToolId: match.tool_id,
+          matchedScope: match.scope,
+          command: command.slice(0, 100)
+        });
+      }
+      if (anyUnstaged) {
+        const remaining = await daemonCtx.staging.listReminders("Stop");
+        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);
+          daemonCtx.logger.info("All VC tools verified, unstaged wrapper", { sessionId });
+        }
+        await remindersState.verificationTools.write(sessionId, toolsState);
+      }
+    }
+    async function stageToolReminderIfNeeded(daemonCtx, reminderId, stagedNames) {
+      if (stagedNames.has(reminderId))
+        return;
+      const reminder = (0, reminder_utils_js_1.resolveReminder)(reminderId, {
+        context: {},
+        assets: daemonCtx.assets
+      });
+      if (!reminder) {
+        daemonCtx.logger.warn("Failed to resolve VC tool reminder", { reminderId });
+        return;
+      }
+      await (0, reminder_utils_js_1.stageReminder)(daemonCtx, "Stop", {
+        ...reminder,
+        stagedAt: { timestamp: Date.now(), turnCount: 0, toolsThisTurn: 0, toolCount: 0 }
       });
     }
   }
@@ -72872,8 +73301,9 @@ var require_stage_stop_bash_changes = __commonJS({
     var core_1 = require_dist4();
     var types_1 = require_dist();
     var picomatch_1 = __importDefault2(require_picomatch2());
-    var staging_handler_utils_js_1 = require_staging_handler_utils();
+    var track_verification_tools_js_1 = require_track_verification_tools();
     var types_js_1 = require_types2();
+    var state_js_1 = require_state3();
     var GIT_STATUS_TIMEOUT_MS = 200;
     var MAX_BASELINES = 50;
     function registerStageBashChanges(context) {
@@ -72910,65 +73340,69 @@ var require_stage_stop_bash_changes = __commonJS({
           });
         }
       });
-      (0, staging_handler_utils_js_1.createStagingHandler)(context, {
+      context.handlers.register({
         id: "reminders:stage-stop-bash-changes",
         priority: 55,
         filter: { kind: "transcript", eventTypes: ["ToolResult"] },
-        execute: async (event, ctx) => {
+        handler: async (event, ctx) => {
           if (!(0, types_1.isTranscriptEvent)(event))
-            return void 0;
+            return;
+          if (event.metadata.isBulkProcessing)
+            return;
+          if (!(0, types_1.isDaemonContext)(ctx))
+            return;
+          const daemonCtx = ctx;
           const toolName = event.payload.toolName;
           if (toolName !== "Bash")
-            return void 0;
+            return;
           const sessionId = event.context?.sessionId;
           if (!sessionId)
-            return void 0;
+            return;
           const baseline = baselines.get(sessionId);
           if (!baseline) {
-            ctx.logger.debug("Bash VC: no baseline for session, skipping", { sessionId });
-            return void 0;
+            daemonCtx.logger.debug("Bash VC: no baseline for session, skipping", { sessionId });
+            return;
           }
           const metrics = event.metadata.metrics;
-          const lastConsumed = await ctx.staging.getLastConsumed("Stop", types_js_1.ReminderIds.VERIFY_COMPLETION);
+          const lastConsumed = await daemonCtx.staging.getLastConsumed("Stop", types_js_1.ReminderIds.VERIFY_COMPLETION);
           if (lastConsumed?.stagedAt) {
             const shouldReactivate = metrics.turnCount > lastConsumed.stagedAt.turnCount;
             if (!shouldReactivate) {
-              ctx.logger.debug("Bash VC: skipped (already consumed this turn)", {
+              daemonCtx.logger.debug("Bash VC: skipped (already consumed this turn)", {
                 currentTurn: metrics.turnCount,
                 lastConsumedTurn: lastConsumed.stagedAt.turnCount
               });
-              return void 0;
+              return;
             }
           }
           const current = await (0, core_1.getGitFileStatus)(cwd, GIT_STATUS_TIMEOUT_MS);
           const baselineSet = new Set(baseline);
           const newFiles = current.filter((f) => !baselineSet.has(f));
-          ctx.logger.debug("Bash VC: git status diff", {
+          daemonCtx.logger.debug("Bash VC: git status diff", {
             baselineCount: baseline.length,
             currentCount: current.length,
             newFileCount: newFiles.length
           });
           if (newFiles.length === 0)
-            return void 0;
+            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) {
-            ctx.logger.debug("Bash VC: new files found but no source code matches", {
-              newFiles
-            });
-            return void 0;
+            daemonCtx.logger.debug("Bash VC: new files found but no source code matches", { newFiles });
+            return;
           }
-          ctx.logger.info("Bash VC: staging verify-completion", {
+          daemonCtx.logger.info("Bash VC: staging per-tool reminders for source changes", {
             sourceMatches,
             turnCount: metrics.turnCount,
             toolCount: metrics.toolCount
           });
           baselines.set(sessionId, current);
-          return {
-            reminderId: types_js_1.ReminderIds.VERIFY_COMPLETION,
-            targetHook: "Stop"
-          };
+          const verificationTools = config.verification_tools ?? {};
+          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);
         }
       });
     }
@@ -73022,28 +73456,52 @@ var require_unstage_verify_completion = __commonJS({
               setAtToolCount: unverifiedState.setAt.toolCount
             });
             if (maxCycles < 0 || unverifiedState.cycleCount < maxCycles) {
-              const reminder = (0, reminder_utils_js_1.resolveReminder)(types_js_1.ReminderIds.VERIFY_COMPLETION, {
-                context: {},
-                assets: daemonCtx.assets
+              const verificationToolsResult = await remindersState.verificationTools.read(sessionId);
+              const toolsState = verificationToolsResult.data;
+              const verificationTools = config.verification_tools ?? {};
+              const hasToolsNeedingVerification = Object.entries(verificationTools).some(([toolName, toolConfig]) => {
+                if (!toolConfig.enabled)
+                  return false;
+                const state = toolsState[toolName];
+                if (!state)
+                  return true;
+                if (state.status === "staged")
+                  return true;
+                if (state.status === "verified" || state.status === "cooldown") {
+                  return state.editsSinceVerified >= toolConfig.clearing_threshold;
+                }
+                return false;
               });
-              if (reminder) {
-                await (0, reminder_utils_js_1.stageReminder)(daemonCtx, "Stop", {
-                  ...reminder,
-                  stagedAt: {
-                    timestamp: Date.now(),
-                    turnCount: unverifiedState.setAt.turnCount,
-                    toolsThisTurn: unverifiedState.setAt.toolsThisTurn,
-                    toolCount: unverifiedState.setAt.toolCount
-                  }
-                });
-                daemonCtx.logger.info("VC unstage: re-staged for next Stop", {
+              if (!hasToolsNeedingVerification) {
+                daemonCtx.logger.info("VC unstage: all tools verified, skipping wrapper re-stage", {
                   sessionId,
-                  cycleCount: unverifiedState.cycleCount,
-                  lastCategory: unverifiedState.lastClassification.category
+                  cycleCount: unverifiedState.cycleCount
                 });
-                return;
+                await remindersState.vcUnverified.delete(sessionId);
               } else {
-                daemonCtx.logger.warn("VC unstage: failed to resolve reminder for re-staging");
+                const reminder = (0, reminder_utils_js_1.resolveReminder)(types_js_1.ReminderIds.VERIFY_COMPLETION, {
+                  context: {},
+                  assets: daemonCtx.assets
+                });
+                if (reminder) {
+                  await (0, reminder_utils_js_1.stageReminder)(daemonCtx, "Stop", {
+                    ...reminder,
+                    stagedAt: {
+                      timestamp: Date.now(),
+                      turnCount: unverifiedState.setAt.turnCount,
+                      toolsThisTurn: unverifiedState.setAt.toolsThisTurn,
+                      toolCount: unverifiedState.setAt.toolCount
+                    }
+                  });
+                  daemonCtx.logger.info("VC unstage: re-staged for next Stop", {
+                    sessionId,
+                    cycleCount: unverifiedState.cycleCount,
+                    lastCategory: unverifiedState.lastClassification.category
+                  });
+                  return;
+                } else {
+                  daemonCtx.logger.warn("VC unstage: failed to resolve reminder for re-staging");
+                }
               }
             } else {
               daemonCtx.logger.info("VC unstage: cycle limit reached, clearing", {
@@ -73059,8 +73517,10 @@ var require_unstage_verify_completion = __commonJS({
               hadState: unverifiedState !== null
             });
           }
-          await daemonCtx.staging.deleteReminder("Stop", types_js_1.ReminderIds.VERIFY_COMPLETION);
-          daemonCtx.logger.debug("VC unstage: deleted staged verify-completion reminder");
+          for (const vcId of types_js_1.ALL_VC_REMINDER_IDS) {
+            await daemonCtx.staging.deleteReminder("Stop", vcId);
+          }
+          daemonCtx.logger.debug("VC unstage: deleted all VC reminders");
         }
       });
     }
@@ -73291,15 +73751,15 @@ var require_staging2 = __commonJS({
     exports2.registerStagingHandlers = registerStagingHandlers;
     var stage_default_user_prompt_1 = require_stage_default_user_prompt();
     var stage_pause_and_reflect_1 = require_stage_pause_and_reflect();
-    var stage_stop_reminders_1 = require_stage_stop_reminders();
     var stage_stop_bash_changes_1 = require_stage_stop_bash_changes();
+    var track_verification_tools_1 = require_track_verification_tools();
     var unstage_verify_completion_1 = require_unstage_verify_completion();
     var stage_persona_reminders_1 = require_stage_persona_reminders();
     var stage_user_profile_reminders_1 = require_stage_user_profile_reminders();
     function registerStagingHandlers(context) {
       (0, stage_default_user_prompt_1.registerStageDefaultUserPrompt)(context);
       (0, stage_pause_and_reflect_1.registerStagePauseAndReflect)(context);
-      (0, stage_stop_reminders_1.registerStageStopReminders)(context);
+      (0, track_verification_tools_1.registerTrackVerificationTools)(context);
       (0, stage_stop_bash_changes_1.registerStageBashChanges)(context);
       (0, unstage_verify_completion_1.registerUnstageVerifyCompletion)(context);
       (0, stage_persona_reminders_1.registerStagePersonaReminders)(context);
@@ -74011,10 +74471,12 @@ var require_orchestrator = __commonJS({
         if (reminder.name === types_js_1.ReminderIds.PAUSE_AND_REFLECT) {
           try {
             const staging = this.deps.getStagingService(sessionId);
-            await staging.deleteReminder("Stop", types_js_1.ReminderIds.VERIFY_COMPLETION);
-            this.deps.logger.debug("Unstaged VC after P&R staged", { sessionId });
+            for (const vcId of types_js_1.ALL_VC_REMINDER_IDS) {
+              await staging.deleteReminder("Stop", vcId);
+            }
+            this.deps.logger.debug("Unstaged all VC reminders after P&R staged", { sessionId });
           } catch (err) {
-            this.deps.logger.warn("Failed to unstage VC after P&R staged", {
+            this.deps.logger.warn("Failed to unstage VC reminders after P&R staged", {
               sessionId,
               error: err instanceof Error ? err.message : String(err)
             });
@@ -74408,6 +74870,7 @@ ${daemonResponse.additionalContext}` : cliResponse.additionalContext;
         hook: hookName
       };
       (0, core_1.logEvent)(logger, core_1.LogEvents.hookReceived(logContext, { cwd: hookInput.cwd, mode: "hook" }));
+      logger.debug("Hook invocation received", { hook: hookName, sessionId: hookInput.sessionId });
       const event = buildHookEvent(hookName, hookInput, correlationId);
       logger.debug("Dispatching hook event to daemon", {
         hook: hookName,
@@ -75213,7 +75676,8 @@ var require_types4 = __commonJS({
         injectPersonaIntoClaude: true,
         defaultLlmProfile: "",
         llmProfiles: {},
-        weights: {}
+        weights: {},
+        persistThroughClear: true
       }
     };
     exports2.RESUME_MIN_CONFIDENCE = 0.7;
@@ -75288,7 +75752,7 @@ var require_persona_selection = __commonJS({
       }
       return weighted[weighted.length - 1].persona;
     }
-    async function selectPersonaForSession(sessionId, config, ctx) {
+    async function selectPersonaForSession(sessionId, config, ctx, options) {
       const personaConfig = {
         ...types_js_1.DEFAULT_SESSION_SUMMARY_CONFIG.personas,
         ...config.personas
@@ -75327,6 +75791,38 @@ var require_persona_selection = __commonJS({
           availablePersonas: Array.from(allPersonas.keys())
         });
       }
+      const persistThroughClear = personaConfig.persistThroughClear ?? true;
+      ctx.logger.debug("Persona clear handoff check", {
+        persistThroughClear,
+        startType: options?.startType,
+        hasClearCache: !!ctx.personaClearCache
+      });
+      if (persistThroughClear && options?.startType === "clear" && ctx.personaClearCache) {
+        const cachedPersonaId = ctx.personaClearCache.consume();
+        if (cachedPersonaId) {
+          const cachedPersona = allPersonas.get(cachedPersonaId);
+          if (cachedPersona) {
+            const personaState2 = {
+              persona_id: cachedPersona.id,
+              selected_from: [cachedPersona.id],
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            const summaryState2 = (0, state_js_1.createSessionSummaryState)(ctx.stateService);
+            await summaryState2.sessionPersona.write(sessionId, personaState2);
+            ctx.logger.info("Preserved persona through clear", {
+              sessionId,
+              personaId: cachedPersona.id,
+              personaName: cachedPersona.display_name
+            });
+            return cachedPersona.id;
+          } else {
+            ctx.logger.warn("Cached persona from clear not found in available personas, falling back to selection", {
+              sessionId,
+              cachedPersonaId
+            });
+          }
+        }
+      }
       const allowList = parsePersonaList(personaConfig.allowList ?? "");
       const blockList = parsePersonaList(personaConfig.blockList ?? "");
       const eligiblePersonas = filterPersonas(allPersonas, allowList, blockList, ctx.logger);
@@ -75413,7 +75909,7 @@ var require_create_first_summary = __commonJS({
       const summaryState = (0, state_js_1.createSessionSummaryState)(ctx.stateService);
       await summaryState.sessionSummary.write(sessionId, placeholder);
       ctx.logger.info("Created placeholder session summary", { sessionId });
-      await (0, persona_selection_js_1.selectPersonaForSession)(sessionId, config, ctx);
+      await (0, persona_selection_js_1.selectPersonaForSession)(sessionId, config, ctx, { startType });
     }
   }
 });
@@ -76273,10 +76769,10 @@ var require_handlers = __commonJS({
         id: "session-summary:init",
         priority: 80,
         filter: { kind: "hook", hooks: ["SessionStart"] },
-        handler: async (event) => {
+        handler: async (event, context2) => {
           if (!(0, core_1.isHookEvent)(event) || !(0, core_1.isSessionStartEvent)(event))
             return;
-          await (0, create_first_summary_js_1.createFirstSessionSummary)(event, ctx);
+          await (0, create_first_summary_js_1.createFirstSessionSummary)(event, context2);
         }
       });
       ctx.handlers.register({
@@ -77532,7 +78028,7 @@ var require_statusline_service = __commonJS({
         if (this.hookInput) {
           const usage = this.hookInput.context_window.current_usage;
           if (usage) {
-            effectiveTokens = usage.input_tokens + usage.cache_creation_input_tokens + usage.cache_read_input_tokens;
+            effectiveTokens = usage.input_tokens + usage.output_tokens + usage.cache_creation_input_tokens + usage.cache_read_input_tokens;
           } else {
             const transcriptTokens = state.currentContextTokens;
             if (transcriptTokens != null && transcriptTokens > 0) {
@@ -77542,8 +78038,9 @@ var require_statusline_service = __commonJS({
               effectiveTokens = 0;
             }
           }
-          if (effectiveTokens === 0) {
-            effectiveTokens = baseline.systemPromptTokens + baseline.systemToolsTokens + baseline.mcpToolsTokens + baseline.customAgentsTokens + baseline.memoryFilesTokens;
+          const baselineMinimum = baseline.totalOverhead - baseline.autocompactBufferTokens;
+          if (effectiveTokens < baselineMinimum) {
+            effectiveTokens = baselineMinimum;
             usingBaseline = true;
           }
         } else {
@@ -82184,7 +82681,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.3" : "dev";
+    var VERSION = true ? "0.1.5" : "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.