🤖 Fix redundant CD detection for tilde vs absolute path mismatch

The bash tool's redundant cd detection was failing when the working directory
used tilde notation (~/path) but the agent used absolute notation (/home/user/path),
or vice versa.

**Problem:**
- SSHRuntime.normalizePath() doesn't expand tildes (can't know remote HOME)
- When cwd="~/workspace/project" and agent does "cd /home/user/workspace/project",
  the paths don't match even though they refer to the same directory
- This caused redundant cd commands to slip through undetected

**Solution:**
Added heuristic matching in bash.ts to catch tilde vs absolute path mismatches:
- If one path has tilde and the other is absolute, extract the suffix after tilde
- Check if the absolute path ends with the same suffix as the tilde path
- Example: cwd="~/project" matches target="/home/user/project"

**Why this approach:**
- Can't query remote HOME without async call (would break normalizePath interface)
- Suffix matching is a reasonable heuristic that catches common cases
- False negatives (missing some redundant cds) are better than false positives

**Test Coverage:**
Added 4 new test cases:
- ✅ cwd has tilde, target is absolute (matching suffix) → rejected
- ✅ cwd is absolute, target has tilde (matching suffix) → rejected
- ✅ cwd has tilde, target is unrelated absolute path → allowed
- ✅ Different paths with same notation → allowed

All tests pass, type checking and linting clean.

Author: ammar-agent

src/runtime/SSHRuntime.ts

@@ -317,7 +317,6 @@ export class SSHRuntime implements Runtime {
       isDirectory: fileType === "directory",
     };
   }
-
   normalizePath(targetPath: string, basePath: string): string {
     // For SSH, handle paths in a POSIX-like manner without accessing the remote filesystem
     const target = targetPath.trim();

src/services/tools/bash.test.ts

@@ -1369,4 +1369,86 @@ describe("SSH runtime redundant cd detection", () => {
       expect(result.error).toContain("Redundant cd");
     }
   });
+
+  // Tests for tilde vs absolute path heuristic matching
+  it("should reject redundant cd when cwd has tilde but target is absolute (matching suffix)", async () => {
+    const remoteCwd = "~/workspace/project/branch";
+    using testEnv = createTestBashToolWithSSH(remoteCwd);
+    const tool = testEnv.tool;
+
+    // Agent uses absolute path that matches the tilde path suffix
+    const args: BashToolArgs = {
+      script: "cd /home/user/workspace/project/branch && echo test",
+      timeout_secs: 5,
+    };
+
+    const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Redundant cd");
+      expect(result.error).toContain("already runs in");
+    }
+  });
+
+  it("should reject redundant cd when cwd is absolute but target has tilde (matching suffix)", async () => {
+    const remoteCwd = "/home/user/workspace/project/branch";
+    using testEnv = createTestBashToolWithSSH(remoteCwd);
+    const tool = testEnv.tool;
+
+    // Agent uses tilde path that matches the absolute path suffix
+    const args: BashToolArgs = {
+      script: "cd ~/workspace/project/branch && echo test",
+      timeout_secs: 5,
+    };
+
+    const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Redundant cd");
+      expect(result.error).toContain("already runs in");
+    }
+  });
+
+  it("should allow cd when cwd has tilde but target is unrelated absolute path", async () => {
+    const remoteCwd = "~/workspace/project/branch";
+    using testEnv = createTestBashToolWithSSH(remoteCwd);
+    const tool = testEnv.tool;
+
+    // Agent uses absolute path that doesn't match the tilde path
+    const args: BashToolArgs = {
+      script: "cd /opt/other/path && echo test",
+      timeout_secs: 5,
+    };
+
+    const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
+
+    // Should NOT be rejected - this is a legitimate cd to a different directory
+    // We can't execute it in tests, so we just verify it's not rejected for redundancy
+    if (!result.success) {
+      expect(result.error).not.toContain("Redundant cd");
+    }
+  });
+
+  it("should allow cd when paths differ even with same notation", async () => {
+    const remoteCwd = "~/workspace/project/branch";
+    using testEnv = createTestBashToolWithSSH(remoteCwd);
+    const tool = testEnv.tool;
+
+    // Different path with same tilde notation
+    const args: BashToolArgs = {
+      script: "cd ~/workspace/project/other && echo test",
+      timeout_secs: 5,
+    };
+
+    const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
+
+    // Should NOT be rejected - different directory
+    if (!result.success) {
+      expect(result.error).not.toContain("Redundant cd");
+    }
+  });
+
+
 });

src/services/tools/bash.ts

@@ -87,7 +87,31 @@ export const createBashTool: ToolFactory = (config: ToolConfiguration) => {
         const normalizedTarget = config.runtime.normalizePath(targetPath, config.cwd);
         const normalizedCwd = config.runtime.normalizePath(".", config.cwd);
 
-        if (normalizedTarget === normalizedCwd) {
+        // Direct comparison
+        let isRedundant = normalizedTarget === normalizedCwd;
+
+        // If direct comparison fails, try heuristic for tilde vs absolute path mismatch
+        // This handles cases like: cwd="~/project" vs target="/home/user/project"
+        if (!isRedundant) {
+          // Check if one has tilde and the other is absolute
+          const cwdHasTilde = normalizedCwd.startsWith("~");
+          const targetHasTilde = normalizedTarget.startsWith("~");
+
+          if (cwdHasTilde !== targetHasTilde) {
+            // Extract the suffix after tilde or find common suffix
+            const cwdSuffix = cwdHasTilde ? normalizedCwd.substring(1) : "";
+            const targetSuffix = targetHasTilde ? normalizedTarget.substring(1) : "";
+
+            // If one has tilde, check if the other ends with the same relative path
+            if (cwdHasTilde && normalizedTarget.endsWith(cwdSuffix)) {
+              isRedundant = true;
+            } else if (targetHasTilde && normalizedCwd.endsWith(targetSuffix)) {
+              isRedundant = true;
+            }
+          }
+        }
+
+        if (isRedundant) {
           return {
             success: false,
             error: `Redundant cd to working directory detected. The tool already runs in ${config.cwd} - no cd needed. Remove the 'cd ${targetPath}' prefix.`,