feat: context sniper UI, browser gating, Apache-2.0, Claude AI review

- native.ts: add extractContext + formatArgs with matchedField/matchedWord
  tracing for "Context Sniper" popup — shows dangerous word in context
- core.ts: extend evaluatePolicy return with matchedField/matchedWord;
  per-field scan after dangerous word found; pass through authorizeHeadless
- daemon/index.ts: gate SSE broadcast and browser open on browser config flag
- LICENSE/package.json/README.md: MIT → Apache-2.0
- .github/workflows/ai-review.yml: add paths-ignore to prevent self-modification
- scripts/ai-review.mjs: upgrade to claude-sonnet-4-6, max_tokens 2048

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: nawi-25

.github/workflows/ai-review.yml

@@ -3,6 +3,9 @@ name: AI Code Review
 on:
   pull_request:
     branches: [main]
+    paths-ignore:
+      - '.github/workflows/ai-review.yml'
+      - 'scripts/ai-review.mjs'
 
 jobs:
   review:

LICENSE

@@ -1,21 +1,183 @@
-MIT License
-
-Copyright (c) 2026 nadav-node9
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship made available under
+      the License, as indicated by a copyright notice that is included in
+      or attached to the work (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other transformations
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and the Derivative Works thereof.
+
+      "Contribution" shall mean, as submitted to the Licensor for inclusion
+      in the Work by the copyright owner or by an individual or Legal Entity
+      authorized to submit on behalf of the copyright owner. For the purposes
+      of this definition, "submitted" means any form of electronic, verbal,
+      or written communication sent to the Licensor or its representations,
+      including but not limited to communication on electronic mailing lists,
+      source code control systems, and issue tracking systems that are managed
+      by, or on behalf of, the Licensor for the purpose of discussing and
+      improving the Work, but excluding communication that is conspicuously
+      marked or designated in writing by the copyright owner as "Not a
+      Contribution."
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and included
+      within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by the combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a cross-claim
+      or counterclaim in a lawsuit) alleging that the Work or any Contribution
+      embodied within the Work constitutes direct or contributory patent
+      infringement, then any patent licenses granted to You under this License
+      for that Work shall terminate as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, You must include a readable copy of the
+          attribution notices contained within such NOTICE file, in
+          at least one of the following places: within a NOTICE text
+          file distributed as part of the Derivative Works; within
+          the Source form or documentation, if provided along with the
+          Derivative Works; or, within a display generated by the
+          Derivative Works, if and wherever such third-party notices
+          normally appear. The contents of the NOTICE file are for
+          informational purposes only and do not modify the License.
+          You may add Your own attribution notices within Derivative
+          Works that You distribute, alongside or in addition to the
+          NOTICE text from the Work, provided that such additional
+          attribution notices cannot be construed as modifying the License.
+
+      You may add Your own license statement for Your modifications and
+      may provide additional grant of rights to use, reproduce, modify,
+      prepare Derivative Works of, convert to other formats, and distribute
+      the contributions, provided such additional grant of rights does not
+      conflict with the terms and conditions of this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or reproducing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or all other
+      commercial damages or losses), even if such Contributor has been
+      advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may offer such
+      obligations only on Your own behalf and on Your sole responsibility,
+      not on behalf of any other Contributor, and only if You agree to
+      indemnify, defend, and hold each Contributor harmless for any
+      liability incurred by, or claims asserted against, such Contributor
+      by reason of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Node9 AI
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package.json

@@ -41,7 +41,7 @@
     "hitl"
   ],
   "author": "Nadav <nadav@node9.ai>",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "files": [
     "dist",
     "README.md",

scripts/ai-review.mjs

@@ -61,8 +61,8 @@ ${truncatedDiff}`;
     console.log('Sending diff to Claude for review...');
     const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
     const message = await client.messages.create({
-      model: 'claude-sonnet-4-5',
-      max_tokens: 1024,
+      model: 'claude-sonnet-4-6',
+      max_tokens: 2048,
       messages: [{ role: 'user', content: prompt }],
     });
 

src/__tests__/core.test.ts

@@ -39,6 +39,8 @@ import {
   getPersistentDecision,
   isDaemonRunning,
   evaluateSmartConditions,
+  shouldSnapshot,
+  DEFAULT_CONFIG,
 } from '../core.js';
 
 // Global spies
@@ -742,6 +744,99 @@ describe('authorizeHeadless — smart rule hard block', () => {
   });
 });
 
+// ── shouldSnapshot ────────────────────────────────────────────────────────────
+describe('shouldSnapshot', () => {
+  const baseConfig = () => JSON.parse(JSON.stringify(DEFAULT_CONFIG)) as typeof DEFAULT_CONFIG;
+
+  it('returns true for a default snapshot tool', () => {
+    const config = baseConfig();
+    expect(shouldSnapshot('str_replace_based_edit_tool', { file_path: 'src/app.ts' }, config)).toBe(
+      true
+    );
+  });
+
+  it('returns true for write_file with no path filters active', () => {
+    const config = baseConfig();
+    expect(shouldSnapshot('write_file', { file_path: 'src/index.ts' }, config)).toBe(true);
+  });
+
+  it('returns false for a non-snapshot tool (bash)', () => {
+    const config = baseConfig();
+    expect(shouldSnapshot('bash', { command: 'ls' }, config)).toBe(false);
+  });
+
+  it('returns false when enableUndo is false', () => {
+    const config = baseConfig();
+    config.settings.enableUndo = false;
+    expect(shouldSnapshot('write_file', { file_path: 'src/app.ts' }, config)).toBe(false);
+  });
+
+  it('respects ignorePaths — skips node_modules', () => {
+    const config = baseConfig();
+    expect(
+      shouldSnapshot('write_file', { file_path: 'node_modules/lodash/index.js' }, config)
+    ).toBe(false);
+  });
+
+  it('respects ignorePaths — skips dist/', () => {
+    const config = baseConfig();
+    expect(shouldSnapshot('edit_file', { file_path: 'dist/bundle.js' }, config)).toBe(false);
+  });
+
+  it('respects ignorePaths — skips .log files', () => {
+    const config = baseConfig();
+    expect(shouldSnapshot('write_file', { file_path: 'logs/app.log' }, config)).toBe(false);
+  });
+
+  it('allows src/ path that does not match any ignorePaths', () => {
+    const config = baseConfig();
+    expect(shouldSnapshot('edit', { file_path: 'src/utils/helper.ts' }, config)).toBe(true);
+  });
+
+  it('respects onlyPaths — skips file outside onlyPaths when set', () => {
+    const config = baseConfig();
+    config.policy.snapshot.onlyPaths = ['src/**'];
+    expect(shouldSnapshot('write_file', { file_path: 'scripts/deploy.sh' }, config)).toBe(false);
+  });
+
+  it('respects onlyPaths — allows file inside onlyPaths', () => {
+    const config = baseConfig();
+    config.policy.snapshot.onlyPaths = ['src/**'];
+    expect(shouldSnapshot('write_file', { file_path: 'src/api/routes.ts' }, config)).toBe(true);
+  });
+
+  it('ignorePaths takes priority over onlyPaths', () => {
+    const config = baseConfig();
+    config.policy.snapshot.onlyPaths = ['src/**'];
+    config.policy.snapshot.ignorePaths.push('src/generated/**');
+    expect(shouldSnapshot('write_file', { file_path: 'src/generated/schema.ts' }, config)).toBe(
+      false
+    );
+  });
+
+  it('handles args with path key instead of file_path', () => {
+    const config = baseConfig();
+    expect(shouldSnapshot('write_file', { path: 'src/app.ts' }, config)).toBe(true);
+  });
+
+  it('handles args with filename key', () => {
+    const config = baseConfig();
+    expect(shouldSnapshot('write_file', { filename: 'src/app.ts' }, config)).toBe(true);
+  });
+
+  it('allows snapshot when no file path present and no onlyPaths set', () => {
+    const config = baseConfig();
+    // No file_path — ignorePaths/onlyPaths checks are skipped
+    expect(shouldSnapshot('write_file', {}, config)).toBe(true);
+  });
+
+  it('user-added tool via config is snapshotted', () => {
+    const config = baseConfig();
+    config.policy.snapshot.tools.push('my_custom_write_tool');
+    expect(shouldSnapshot('my_custom_write_tool', { file_path: 'src/foo.ts' }, config)).toBe(true);
+  });
+});
+
 describe('isDaemonRunning', () => {
   it('returns false when PID file does not exist', () => {
     // existsSpy returns false (set in beforeEach)

src/cli.ts

@@ -12,6 +12,7 @@ import {
   getConfig,
   _resetConfigCache,
   explainPolicy,
+  shouldSnapshot,
 } from './core';
 import { setupClaude, setupGemini, setupCursor } from './setup';
 import { startDaemon, stopDaemon, daemonStatus, DAEMON_PORT, DAEMON_HOST } from './daemon/index';
@@ -1045,19 +1046,7 @@ program
         // Snapshot BEFORE the tool runs (PreToolUse) so undo can restore to
         // the state prior to this change. Snapshotting after (PostToolUse)
         // captures the changed state, making undo a no-op.
-        const STATE_CHANGING_TOOLS_PRE = [
-          'write_file',
-          'edit_file',
-          'edit',
-          'replace',
-          'terminal.execute',
-          'str_replace_based_edit_tool',
-          'create_file',
-        ];
-        if (
-          config.settings.enableUndo &&
-          STATE_CHANGING_TOOLS_PRE.includes(toolName.toLowerCase())
-        ) {
+        if (shouldSnapshot(toolName, toolInput, config)) {
           await createShadowSnapshot(toolName, toolInput);
         }
 
@@ -1186,16 +1175,10 @@ program
         fs.appendFileSync(logPath, JSON.stringify(entry) + '\n');
 
         const config = getConfig();
-        const STATE_CHANGING_TOOLS = [
-          'bash',
-          'shell',
-          'write_file',
-          'edit_file',
-          'replace',
-          'terminal.execute',
-        ];
-
-        if (config.settings.enableUndo && STATE_CHANGING_TOOLS.includes(tool.toLowerCase())) {
+
+        // PostToolUse snapshot is a fallback for tools not covered by PreToolUse.
+        // Uses the same configurable snapshot policy.
+        if (shouldSnapshot(tool, {}, config)) {
           await createShadowSnapshot();
         }
       } catch {