vibe-coding-master 0.7.37 → 0.7.38

package/README.md

@@ -471,7 +471,10 @@ VCM bundles the Claude Code LSP bridge and loads it for Architect, Coder, and
 Reviewer sessions, including CCR launches. The project environment must still
 provide the language server for each detected language: `rust-analyzer`,
 `typescript-language-server`, `pyright-langserver`, `gopls`, `clangd`, or
-`jdtls`. Harness Studio reports a missing executable or failed startup probe
+`jdtls`. Architect, Coder, and Reviewer do not receive the Grep tool, and the
+Harness guard rejects shell text-search commands for those roles so unresolved
+semantic relationships cannot be hidden by textual fallback. Harness Studio
+reports a missing executable or failed readiness probe
 with the backend diagnostic.
 
 Harness Engineer is task-scoped and runs from the active task worktree. The

package/dist/backend/cli/install-vcm-harness.js

@@ -53,6 +53,7 @@ const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";
 const VCM_AUTO_MEMORY_ENABLED = false;
 const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
+    { eventName: "PreToolUse", matcher: "Grep", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
     { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
@@ -65,18 +66,18 @@ const AGENT_FRONTMATTER = {
     },
     architect: {
         description: "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync.",
-        tools: "Read, Grep, Glob, Bash, Edit, Write, Agent, LSP"
+        tools: "Read, Glob, Bash, Edit, Write, Agent, LSP"
     },
     coder: {
         description: "VCM implementation role for scoped code changes and focused tests.",
-        tools: "Read, Grep, Glob, Bash, Edit, Write, Agent, LSP"
+        tools: "Read, Glob, Bash, Edit, Write, Agent, LSP"
     },
     tester: {
         description: "VCM testing role for validation, test adequacy, approved-scope validation, and risk findings."
     },
     reviewer: {
         description: "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.",
-        tools: "Read, Grep, Glob, Bash, Write, LSP"
+        tools: "Read, Glob, Bash, Write, LSP"
     },
     translator: {
         description: "VCM task-scoped translation tool role for conversation translation, file translation, bootstrap, and memory updates."
@@ -99,6 +100,11 @@ const REQUIRED_AGENT_TOOLS = {
     coder: ["Agent", "LSP"],
     reviewer: ["LSP"]
 };
+const FORBIDDEN_AGENT_TOOLS = {
+    architect: ["Grep"],
+    coder: ["Grep"],
+    reviewer: ["Grep"]
+};
 const MANAGED_FILES = [
     {
         path: "CLAUDE.md",
@@ -266,7 +272,7 @@ const WHOLE_FILES = [
         path: ".claude/skills/vcm-code-navigation/SKILL.md",
         category: "skill",
         mode: 0o644,
-        content: renderSkillFile("VCM Code Navigation Skill", "vcm-code-navigation", "Use when Architect or Reviewer must resolve code symbols, references, implementations, call hierarchies, or bounded dependency paths.", renderVcmCodeNavigationSkillRules())
+        content: renderSkillFile("VCM Code Navigation Skill", "vcm-code-navigation", "Use when Architect, Coder, or Reviewer must resolve code symbols, references, implementations, call hierarchies, or bounded dependency paths.", renderVcmCodeNavigationSkillRules())
     },
     {
         path: ".claude/skills/vcm-final-acceptance/SKILL.md",
@@ -672,6 +678,9 @@ async function installManagedFile({ projectRoot, definition, dryRun, operations
     for (const requiredTool of REQUIRED_AGENT_TOOLS[definition.agentName] ?? []) {
         nextContent = ensureAgentTool(nextContent, requiredTool);
     }
+    for (const forbiddenTool of FORBIDDEN_AGENT_TOOLS[definition.agentName] ?? []) {
+        nextContent = removeAgentTool(nextContent, forbiddenTool);
+    }
     await writeIfChanged({
         targetPath,
         relativePath: definition.path,
@@ -734,6 +743,22 @@ function ensureAgentTool(content, requiredTool) {
     const nextTools = [...tools, requiredTool].join(", ");
     return content.replace(frontmatterMatch[0], frontmatterMatch[0].replace(toolsMatch[0], `tools: ${nextTools}`));
 }
+function removeAgentTool(content, forbiddenTool) {
+    const frontmatterMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
+    if (!frontmatterMatch) {
+        return content;
+    }
+    const toolsMatch = frontmatterMatch[0].match(/^tools:\s*(.*)$/m);
+    if (!toolsMatch) {
+        return content;
+    }
+    const tools = toolsMatch[1].split(",").map((tool) => tool.trim()).filter(Boolean);
+    const nextTools = tools.filter((tool) => tool !== forbiddenTool);
+    if (nextTools.length === tools.length) {
+        return content;
+    }
+    return content.replace(frontmatterMatch[0], frontmatterMatch[0].replace(toolsMatch[0], `tools: ${nextTools.join(", ")}`));
+}
 function migrateLegacyManagedFile(definition, currentContent, block) {
     const legacyContent = definition.legacyWholeFile?.trimEnd();
     if (!legacyContent) {

package/dist/backend/services/harness-service.js

@@ -53,6 +53,7 @@ const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";
 const VCM_AUTO_MEMORY_ENABLED = false;
 const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
+    { eventName: "PreToolUse", matcher: "Grep", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
     { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
@@ -116,7 +117,7 @@ const HARNESS_FILES = [
         kind: "skill-vcm-code-navigation",
         path: ".claude/skills/vcm-code-navigation/SKILL.md",
         title: "VCM Code Navigation Skill",
-        frontmatter: renderSkillFrontmatter("vcm-code-navigation", "Use when Architect or Reviewer must resolve code symbols, references, implementations, call hierarchies, or bounded dependency paths."),
+        frontmatter: renderSkillFrontmatter("vcm-code-navigation", "Use when Architect, Coder, or Reviewer must resolve code symbols, references, implementations, call hierarchies, or bounded dependency paths."),
         ownership: "whole-file",
         renderRules: renderVcmCodeNavigationSkillRules
     },
@@ -198,7 +199,8 @@ const HARNESS_FILES = [
         title: "Reviewer Agent",
         memoryBlock: true,
         requiredTools: ["LSP"],
-        frontmatter: renderAgentFrontmatter("reviewer", "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.", { tools: "Read, Grep, Glob, Bash, Write, LSP" }),
+        forbiddenTools: ["Grep"],
+        frontmatter: renderAgentFrontmatter("reviewer", "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.", { tools: "Read, Glob, Bash, Write, LSP" }),
         renderRules: renderReviewerAgentRules
     },
     {
@@ -272,8 +274,9 @@ const HARNESS_FILES = [
         title: "Architect Agent",
         memoryBlock: true,
         requiredTools: ["Agent", "LSP"],
+        forbiddenTools: ["Grep"],
         blankLineBeforeEnd: true,
-        frontmatter: renderAgentFrontmatter("architect", "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync.", { tools: "Read, Grep, Glob, Bash, Edit, Write, Agent, LSP" }),
+        frontmatter: renderAgentFrontmatter("architect", "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync.", { tools: "Read, Glob, Bash, Edit, Write, Agent, LSP" }),
         renderRules: renderArchitectHarnessRules
     },
     {
@@ -282,7 +285,8 @@ const HARNESS_FILES = [
         title: "Coder Agent",
         memoryBlock: true,
         requiredTools: ["Agent", "LSP"],
-        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests.", { tools: "Read, Grep, Glob, Bash, Edit, Write, Agent, LSP" }),
+        forbiddenTools: ["Grep"],
+        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests.", { tools: "Read, Glob, Bash, Edit, Write, Agent, LSP" }),
         renderRules: renderCoderHarnessRules
     },
     {
@@ -1220,7 +1224,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
         const migratedContent = migrateLegacyHarnessFile(definition, currentContent, expectedBlock);
         if (migratedContent) {
             const memoryUpdatedContent = definition.memoryBlock ? ensureVcmMemoryBlock(migratedContent) : migratedContent;
-            const nextContent = ensureAgentTools(memoryUpdatedContent, definition.requiredTools);
+            const nextContent = normalizeAgentTools(memoryUpdatedContent, definition.requiredTools, definition.forbiddenTools);
             return {
                 definition,
                 status: {
@@ -1239,7 +1243,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
             };
         }
         const insertedContent = `${currentContent.trimEnd()}\n\n${expectedBlock}\n`;
-        const nextContent = ensureAgentTools(insertedContent, definition.requiredTools);
+        const nextContent = normalizeAgentTools(insertedContent, definition.requiredTools, definition.forbiddenTools);
         return {
             definition,
             status: {
@@ -1261,7 +1265,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
     const currentBlock = match[0];
     const blockUpdatedContent = currentContent.replace(managedBlockPattern, expectedBlock);
     const memoryUpdatedContent = definition.memoryBlock ? ensureVcmMemoryBlock(blockUpdatedContent) : blockUpdatedContent;
-    const nextContent = ensureAgentTools(memoryUpdatedContent, definition.requiredTools);
+    const nextContent = normalizeAgentTools(memoryUpdatedContent, definition.requiredTools, definition.forbiddenTools);
     const action = currentContent === nextContent ? "ok" : "update";
     return {
         definition,
@@ -1392,6 +1396,26 @@ function ensureAgentTool(content, requiredTool) {
 function ensureAgentTools(content, requiredTools) {
     return (requiredTools ?? []).reduce(ensureAgentTool, content);
 }
+function removeAgentTool(content, forbiddenTool) {
+    const frontmatterMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
+    if (!frontmatterMatch) {
+        return content;
+    }
+    const toolsMatch = frontmatterMatch[0].match(/^tools:\s*(.*)$/m);
+    if (!toolsMatch) {
+        return content;
+    }
+    const tools = toolsMatch[1].split(",").map((tool) => tool.trim()).filter(Boolean);
+    const nextTools = tools.filter((tool) => tool !== forbiddenTool);
+    if (nextTools.length === tools.length) {
+        return content;
+    }
+    return content.replace(frontmatterMatch[0], frontmatterMatch[0].replace(toolsMatch[0], `tools: ${nextTools.join(", ")}`));
+}
+function normalizeAgentTools(content, requiredTools, forbiddenTools) {
+    const required = ensureAgentTools(content, requiredTools);
+    return (forbiddenTools ?? []).reduce(removeAgentTool, required);
+}
 function migrateLegacyHarnessFile(definition, currentContent, block) {
     const legacyContent = definition.legacyWholeFile?.trimEnd();
     if (!legacyContent) {
@@ -1479,7 +1503,7 @@ function withVcmClaudeHooks(settings) {
             ? hooks[definition.eventName]
             : [];
         hooks[definition.eventName] = [
-            ...existingMatchers.filter((entry) => !isVcmHookMatcher(entry)),
+            ...existingMatchers,
             {
                 ...(definition.matcher ? { matcher: definition.matcher } : {}),
                 hooks: [

package/dist/backend/templates/harness/architect-agent.js

@@ -19,6 +19,13 @@ ${renderRoleMemoryRules("architect")}
 - In Debug Mode and Architecture Diagnosis Mode, writing baseline unit tests for changed code and running required L0/L1 plus applicable L2/L3 checks are part of the implementation duty; tester still owns final validation.
 - Do not make product priority or approval decisions; route those questions back to project-manager.
 
+### Semantic Code Navigation
+
+- Use \`vcm-code-navigation\` whenever work requires code definitions, implementations, references, callers, callees, or behavior paths. This applies in every Architect mode and in direct user communication.
+- Use LSP for semantic relationships. Use Glob to locate files, Read to inspect complete code, and generated context, architecture documents, or runtime evidence for boundaries LSP does not model.
+- Do not use the Grep tool or shell text-search commands such as \`grep\`, \`rg\`, or \`git grep\`.
+- If LSP cannot resolve a required project-owned relationship, record it as unresolved. Do not replace semantic evidence with text matches.
+
 ### Work Persistence
 
 - Treat Architect artifacts, not Session memory, as continuation state.
@@ -45,9 +52,8 @@ ${renderRoleMemoryRules("architect")}
 ### Planning Code Reading
 
 - Do not plan from session memory, architecture docs, generated context, or code comments alone. Re-read current-worktree source and verify actual behavior from implementation.
-- Use \`vcm-code-navigation\` for symbol definitions, implementations, references, call hierarchies, and bounded behavior paths. Start from generated indexes, use LSP semantic navigation when available, then read every resolved callable unit in full.
-- Use structural search when available and Grep for dynamic registrations, configuration or string edges, macros not resolved by LSP, documentation, and explicit fallback discovery. When LSP is available, do not treat Grep as proof of a complete symbol, caller, implementation, or reference set.
-- If LSP is unavailable or cannot resolve a required relationship, record the limitation and exact fallback evidence in \`architecture-evidence.md\`; do not claim compiler-accurate completeness from text search alone.
+- Use \`vcm-code-navigation\` for symbol definitions, implementations, references, call hierarchies, and bounded behavior paths. Start from generated indexes, use LSP semantic navigation, then read every resolved callable unit in full.
+- If LSP cannot resolve a required project-owned relationship, record the limitation in \`architecture-evidence.md\` and leave it unresolved.
 - Define the planning boundary as the affected feature or module and identify every existing or intended observable entry point for the behavior being changed.
 - Read the complete implementation of each relevant existing entry point.
 - Follow every project-owned call path the plan will change through cross-module calls, state reads and writes, persistence, side effects, completion and failure signals, and consumers.
@@ -202,7 +208,7 @@ The code-reading phase is complete only when:
 - every indirect callback, event, hook, queue, route, and dynamic dispatch path has been resolved
 - every relevant state reader and writer has been read
 - every relevant cross-file surface caller and consumer has been read
-- every semantic relationship records LSP, structural-search, Grep-fallback, runtime, external-boundary, or generated-boundary evidence
+- every semantic relationship records LSP, runtime, external-boundary, or generated-boundary evidence
 - no unresolved project-owned symbol remains
 
 Do not diagnose the root cause or choose a fix before the Code Reading Closure is complete.

package/dist/backend/templates/harness/coder-agent.js

@@ -12,6 +12,13 @@ ${renderRoleMemoryRules("coder")}
 - Implement assigned file/function-level scaffold items; do not analyze, review, dispute, or redesign architecture, module boundaries, public contracts, dependency direction, durable docs strategy, validation strategy, or final test adequacy.
 - Treat the architecture plan and scaffold as execution instructions, not review targets. Do not critique, reinterpret, or challenge them during Coder work.
 
+### Semantic Code Navigation
+
+- Use \`vcm-code-navigation\` whenever implementation requires code definitions, implementations, references, callers, callees, or behavior paths.
+- Use LSP for semantic relationships. Use Glob to locate files and Read to inspect complete code.
+- Do not use the Grep tool or shell text-search commands such as \`grep\`, \`rg\`, or \`git grep\`.
+- If LSP cannot resolve a required project-owned relationship, record it as unresolved in the completion evidence. Do not replace semantic evidence with text matches.
+
 ### Shared Coding Standards
 
 - Before editing production code or tests, read and follow \`docs/CODING_STANDARDS.md\`.
@@ -26,7 +33,7 @@ ${renderRoleMemoryRules("coder")}
 - Do not stop before editing because of predicted architecture, design, contract, validation, or test failure; implement the assigned scaffold first.
 - Use \`.ai/generated/module-index.json\` to locate approved module source and test files.
 - Use \`.ai/generated/public-surface.json\` to avoid accidental public API drift.
-- When LSP is available, use definitions and references to locate assigned callable surfaces precisely. Use Grep for text or dynamic edges, not to broaden or reinterpret the approved implementation scope.
+- Use LSP definitions and references to locate assigned callable surfaces precisely.
 
 ### Implementation
 

package/dist/backend/templates/harness/gate-review.js

@@ -15,20 +15,23 @@ Use only these decisions:
 - \`approve\`: required gate evidence is present, current, internally consistent, sufficient for that gate, and has no gate-blocking finding.
 - \`request_changes\`: evidence is missing, stale, contradictory, incomplete, insufficient, not reviewable, or unsafe.
 
+## Semantic Code Navigation
+
+Use \`vcm-code-navigation\` whenever a gate requires code definitions,
+implementations, references, callers, callees, or behavior paths. Use LSP for
+semantic relationships, Glob to locate files, Read to inspect complete code,
+and generated context, architecture documents, or runtime evidence for
+boundaries LSP does not model. Do not use the Grep tool or shell text-search
+commands such as \`grep\`, \`rg\`, or \`git grep\`. If LSP cannot resolve
+a required project-owned relationship, treat that evidence as unresolved and
+return \`request_changes\`; do not replace semantic evidence with text matches.
+
 Every Gate Review is a complete review of the current gate inputs. Review all
 required evidence and rerun every required mechanical check before deciding.
 Do not carry forward prior conclusions, closed checks, or partial verification.
 Resolving prior findings does not replace the complete review. Return \`approve\`
 or \`request_changes\` only after the review is complete.
 
-Use \`vcm-code-navigation\` whenever a gate requires definitions, implementations,
-references, call hierarchies, or a bounded behavior path. Use LSP semantic
-navigation when available and read every resolved callable unit in full. Use
-structural search when available and Grep for dynamic or textual edges and
-explicit fallback discovery. Do not treat Grep as proof of a complete symbol,
-caller, implementation, or reference set when LSP is available. If LSP cannot
-resolve required evidence, record the limitation and exact fallback basis.
-
 ## Architecture Plan Gate
 
 Format is necessary but not sufficient. Do not approve an architecture plan
@@ -469,7 +472,7 @@ If there are no findings, write:
 None.
 \`\`\`
 
-Use Bash only for read-only inspection such as \`git diff\`, \`git status\`, \`git show\`, \`ls\`, \`rg\`, \`sed\`, or \`cat\`. Do not run tests, builds, formatters, generators, package managers, or commands that modify files.
+Use Bash only for read-only inspection such as \`git diff\`, \`git status\`, \`git show\`, \`ls\`, \`sed\`, or \`cat\`. Do not run shell text-search commands, tests, builds, formatters, generators, package managers, or commands that modify files.
 
 Review only code, architecture, and documents; do not perform validation. Do not edit code, tests, durable docs, role files, route files, or handoff artifacts. Do not assign findings or remediation work to VCM roles, choose fixes, decide Replan, or decide whether user intervention is needed.
 

package/dist/backend/templates/harness/vcm-code-navigation-skill.js

@@ -1,22 +1,22 @@
 export function renderVcmCodeNavigationSkillRules() {
     return `## Purpose
 
-Use this skill when Architect or Reviewer must establish symbol definitions, implementations, references, callers, callees, or a bounded behavior path from current-worktree evidence.
+Use this skill when Architect, Coder, or Reviewer must establish symbol definitions, implementations, references, callers, callees, or a bounded behavior path from current-worktree evidence.
 
 ## Navigation Order
 
 1. Define the affected feature or module boundary and locate entry symbols with \`.ai/generated/module-index.json\` and \`.ai/generated/public-surface.json\` when available.
-2. When LSP is available, use workspace or file symbols, definitions, implementations, references, and incoming or outgoing call hierarchy to resolve project-owned relationships.
+2. Use LSP workspace or file symbols, definitions, implementations, references, and incoming or outgoing call hierarchy to resolve project-owned relationships.
 3. Read the complete project-owned callable unit at every resolved location.
 4. Expand one project-owned dependency hop at a time until the required behavior path has no unresolved symbol.
-5. Use structural search when available, and use Grep for dynamic registrations, configuration or string edges, macros not resolved by LSP, documentation, and explicit fallback discovery.
+5. Use Glob, generated context, architecture documents, and runtime evidence to locate dynamic registrations, configuration or string edges, macros, documentation, and external boundaries that LSP does not model.
 
 ## Evidence
 
-- Record each resolved relationship and whether it came from LSP, structural search, Grep fallback, runtime evidence, or a generated boundary.
-- Do not treat a Grep result as proof of a complete definition, caller, implementation, or reference set when LSP is available.
+- Record each resolved relationship and whether it came from LSP, runtime evidence, an external boundary, or a generated boundary.
 - When an empty LSP result contradicts a direct call in the code, another LSP result, or runtime evidence, treat the relationship as unresolved. Record the contradiction and use exact fallback evidence.
-- If LSP is unavailable or cannot resolve a relationship, record that limitation and the exact fallback evidence. Do not describe text-search results as compiler-accurate or complete.
+- If LSP is unavailable or cannot resolve a required project-owned relationship, record that limitation and leave the relationship unresolved. Do not substitute text search for semantic navigation.
+- Do not use the Grep tool or shell text-search commands such as \`grep\`, \`rg\`, or \`git grep\`.
 - Generated indexes and architecture docs locate likely code; reading current-worktree implementation establishes behavior.
 
 ## Context Boundary

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.7.37",
+  "version": "0.7.38",
   "description": "Local GUI session cockpit for Claude Code role sessions.",
   "type": "module",
   "files": [

package/scripts/harness-tools/vcm-bash-guard

@@ -1,11 +1,9 @@
 #!/usr/bin/env python3
-"""VCM PreToolUse guard for supervised Bash inside VCM role sessions.
+"""VCM PreToolUse guard for supervised tools inside VCM role sessions.
 
-Reads the Claude Code PreToolUse hook payload on stdin. When the Bash tool
-call would start background work (run_in_background, nohup, setsid, disown,
-or a lone '&'), or composes a supervised long-job tool with another shell
-command, it prints a deny decision that redirects the role to the
-vcm-long-running-validation skill. Anything else is allowed by staying silent.
+Reads the Claude Code PreToolUse hook payload on stdin. It enforces supervised
+Bash execution for every VCM role and prevents LSP-enabled roles from replacing
+semantic code navigation with the Grep tool or shell text-search commands.
 
 Quoted payloads of `sh -c` / `bash -lc` style invocations are executable
 shell code, so they are scanned recursively. `.ai/tools/run-long-check` is the
@@ -13,6 +11,7 @@ only sanctioned detached worker; the command it runs must still stay in the
 supervised foreground process group.
 """
 import json
+import os
 import re
 import sys
 
@@ -22,6 +21,11 @@ SKILL_HINT = (
     "`.ai/tools/watch-job <job-id>` in the same turn, repeating watch-job "
     "until it reports a terminal result."
 )
+CODE_NAV_HINT = (
+    "Use LSP, Glob, Read, generated context, architecture documents, or runtime "
+    "evidence; do not substitute text search."
+)
+LSP_ROLES = {"architect", "coder", "reviewer"}
 
 MAX_NESTED_SHELL_DEPTH = 3
 QUOTED = re.compile(r"'([^']*)'|\"([^\"]*)\"")
@@ -40,6 +44,20 @@ RUN_LONG_CHECK_SHELL_STRING = re.compile(
     r"(?:-\w+\s+)*-\w*c\w*(?:\s|$)"
 )
 COMMAND_SUBSTITUTION = re.compile(r"\$\(([^()]*)\)|`([^`]*)`")
+TEXT_SEARCH_COMMAND = re.compile(
+    r"(?:^|[;&|()\n`])\s*"
+    r"(?:(?:[A-Za-z_][A-Za-z0-9_]*=[^\s;&|()]+)\s+)*"
+    r"(?:env(?:\s+(?:-[^\s]+|[A-Za-z_][A-Za-z0-9_]*=[^\s]+))*\s+)?"
+    r"(?:command\s+|sudo(?:\s+-[^\s]+)*\s+)?"
+    r"(?:[^\s;&|()]*/)?(?:grep|egrep|fgrep|rg|ripgrep)(?=\s|$|[;&|()])"
+)
+GIT_GREP_COMMAND = re.compile(
+    r"(?:^|[;&|()\n`])\s*(?:git)(?:\s+-[^\s]+)*\s+grep(?=\s|$|[;&|()])"
+)
+WRAPPED_TEXT_SEARCH_COMMAND = re.compile(
+    r"(?:^|\s)(?:xargs(?:\s+-[^\s]+)*|-exec|-execdir)\s+"
+    r"(?:[^\s;&|()]*/)?(?:grep|egrep|fgrep|rg|ripgrep)(?=\s|$|[;&|()])"
+)
 
 
 def strip_quoted(command: str) -> str:
@@ -83,7 +101,7 @@ def protected_tool_invoked(command_without_quotes: str) -> bool:
     return bool(PROTECTED_TOOL_INVOCATION.search(command_without_quotes))
 
 
-def scan_shell_command(command: str, depth: int = 0) -> list[str]:
+def scan_shell_command(command: str, depth: int = 0, forbid_text_search: bool = False) -> list[str]:
     reasons = []
     stripped = strip_escaped_characters(strip_quoted(command))
     if re.search(r"(?:^|[\s;&|(])(?:nohup|setsid)(?:\s|$)", stripped):
@@ -92,6 +110,12 @@ def scan_shell_command(command: str, depth: int = 0) -> list[str]:
         reasons.append("disown is forbidden")
     if unquoted_ampersand(stripped):
         reasons.append("'&' background execution is forbidden")
+    if forbid_text_search and (
+        TEXT_SEARCH_COMMAND.search(stripped)
+        or GIT_GREP_COMMAND.search(stripped)
+        or WRAPPED_TEXT_SEARCH_COMMAND.search(stripped)
+    ):
+        reasons.append("text-search commands are forbidden for this LSP-enabled role")
 
     if protected_tool_invoked(stripped):
         if SHELL_CONTROL_OPERATOR.search(stripped):
@@ -104,17 +128,17 @@ def scan_shell_command(command: str, depth: int = 0) -> list[str]:
         for segment in quoted_segments(command):
             if protected_tool_invoked(strip_escaped_characters(strip_quoted(segment))):
                 reasons.append("run-long-check and watch-job must not be invoked through a shell command string")
-            reasons.extend(scan_shell_command(segment, depth + 1))
+            reasons.extend(scan_shell_command(segment, depth + 1, forbid_text_search))
     if depth < MAX_NESTED_SHELL_DEPTH:
         for substitution in double_quoted_command_substitutions(command):
             nested_stripped = strip_escaped_characters(strip_quoted(substitution))
             if protected_tool_invoked(nested_stripped):
                 reasons.append("run-long-check and watch-job must not be invoked through command substitution")
-            reasons.extend(scan_shell_command(substitution, depth + 1))
+            reasons.extend(scan_shell_command(substitution, depth + 1, forbid_text_search))
     return reasons
 
 
-def guard_reasons(tool_input: dict) -> list[str]:
+def guard_reasons(tool_input: dict, forbid_text_search: bool = False) -> list[str]:
     reasons = []
     if tool_input.get("run_in_background"):
         reasons.append("Bash run_in_background is forbidden")
@@ -122,7 +146,7 @@ def guard_reasons(tool_input: dict) -> list[str]:
     command = tool_input.get("command")
     command = command if isinstance(command, str) else ""
 
-    reasons.extend(scan_shell_command(command))
+    reasons.extend(scan_shell_command(command, forbid_text_search=forbid_text_search))
     return list(dict.fromkeys(reasons))
 
 
@@ -132,15 +156,26 @@ def main() -> int:
         payload = json.loads(raw) if raw.strip() else {}
     except ValueError:
         return 0
-    if payload.get("tool_name") != "Bash":
+    tool_name = payload.get("tool_name")
+    role = os.environ.get("VCM_ROLE", "").strip()
+    forbid_text_search = role in LSP_ROLES
+    if tool_name == "Grep" and forbid_text_search:
+        reasons = ["the Grep tool is forbidden for this LSP-enabled role"]
+    elif tool_name == "Bash":
+        tool_input = payload.get("tool_input")
+        tool_input = tool_input if isinstance(tool_input, dict) else {}
+        reasons = guard_reasons(tool_input, forbid_text_search=forbid_text_search)
+    else:
         return 0
-
-    tool_input = payload.get("tool_input")
-    tool_input = tool_input if isinstance(tool_input, dict) else {}
-    reasons = guard_reasons(tool_input)
     if not reasons:
         return 0
 
+    hints = []
+    if any("text-search" in reason or "Grep tool" in reason for reason in reasons):
+        hints.append(CODE_NAV_HINT)
+    if any("text-search" not in reason and "Grep tool" not in reason for reason in reasons):
+        hints.append(SKILL_HINT)
+
     print(
         json.dumps(
             {
@@ -148,7 +183,7 @@ def main() -> int:
                     "hookEventName": "PreToolUse",
                     "permissionDecision": "deny",
                     "permissionDecisionReason": (
-                        "VCM denied this Bash call (" + "; ".join(reasons) + "). " + SKILL_HINT
+                        "VCM denied this tool call (" + "; ".join(reasons) + "). " + " ".join(hints)
                     ),
                 }
             }