fix: bug fix (#41)

* fix: hampering the base_branch branch issue

* ws: apply agent changes

* fix: screenshot attachment feature

* feat: add overall comment feature

* fix: follow only works when we scrolled till bottom

* fix: time passed during chatting

* fix: open session launches new terminal window instead of blocking dashboard

* fix: resume with overall comments

* fix: update total isolation using prehook

* fix: update git diff

Author: amandal0903

src/cli/dashboard.ts

@@ -89,7 +89,7 @@ async function buildEntries(config: any, state: any): Promise<WorkstreamEntry[]>
     if (hasWorktree) {
       const [bi, ds, dirtyResult] = await Promise.all([
         getBranchInfo(branch),
-        getDiffStats(branch),
+        getDiffStats(branch, worktreePath),
         $`git -C ${worktreePath} status --porcelain`.quiet().catch(() => null),
       ]);
       branchInfo = bi;
@@ -99,7 +99,7 @@ async function buildEntries(config: any, state: any): Promise<WorkstreamEntry[]>
 
     const hasSession = !!state?.currentRun?.workstreams?.[def.name]?.sessionId;
     const commentsData = await loadComments(def.name);
-    const commentCount = commentsData.comments.length;
+    const commentCount = commentsData.comments.length + (commentsData.overallComment ? 1 : 0);
     const pendingPromptText = await loadPendingPrompt(def.name);
 
     return {
@@ -115,6 +115,7 @@ async function buildEntries(config: any, state: any): Promise<WorkstreamEntry[]>
       hasPendingPrompt: !!pendingPromptText,
       pendingPromptText: pendingPromptText ?? undefined,
       isDirty,
+      startedAt: state?.currentRun?.workstreams?.[def.name]?.startedAt,
     } as WorkstreamEntry;
   });
 
@@ -191,35 +192,42 @@ async function actionOpenEditor(name: string, state: any, config: any, editorOpt
 
 // ─── Action: Open Claude session (interactive) ───────────────────────────────
 
-async function actionOpenSession(name: string, ws: WorkstreamState, state: ProjectState) {
-  if (!ws.sessionId) {
-    console.error("Error: no session ID captured for this workstream.");
-    return;
-  }
+async function actionOpenSession(name: string, ws: WorkstreamState, _state: ProjectState): Promise<boolean> {
+  if (!ws.sessionId) return false;
 
+  // Open the Claude session in a new terminal window so it doesn't conflict
+  // with the dashboard's TUI (alternate screen + raw mode). The session runs
+  // independently, allowing the user to keep using the dashboard.
   const absWorktreePath = resolve(ws.worktreePath);
-  const proc = Bun.spawn(["claude", "--dangerously-skip-permissions", "--resume", ws.sessionId], {
-    cwd: absWorktreePath,
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-  });
-
-  const exitCode = await proc.exited;
-  console.log(`\nReturned from Claude session for "${name}".`);
-
-  const { $ } = await import("bun");
-  const gitStatus = await $`git -C ${absWorktreePath} status --porcelain`.quiet().catch(() => null);
-  const changes = gitStatus?.stdout.toString().trim();
-  if (changes) {
-    await $`git -C ${absWorktreePath} add -A`.quiet().catch(() => {});
-    await $`git -C ${absWorktreePath} commit -m "ws: apply agent changes"`.quiet().catch(() => {});
+  const shellCmd = `cd ${shellEscape(absWorktreePath)} && claude --resume ${shellEscape(ws.sessionId)}`;
+
+  if (process.platform === "darwin") {
+    // Use AppleScript to open a new Terminal.app window with the resume command
+    const script = `tell application "Terminal"
+  activate
+  do script "${shellCmd.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"
+end tell`;
+    const proc = Bun.spawn(["osascript", "-e", script], { stdio: ["ignore", "pipe", "ignore"] });
+    await proc.exited;
+    return proc.exitCode === 0;
+  } else {
+    // Try common Linux terminal emulators
+    const terminals = [
+      ["gnome-terminal", "--", "bash", "-c", shellCmd],
+      ["xterm", "-e", shellCmd],
+    ];
+    for (const args of terminals) {
+      try {
+        Bun.spawn(args, { stdio: ["ignore", "ignore", "ignore"] });
+        return true;
+      } catch {}
+    }
+    return false;
   }
+}
 
-  ws.status = exitCode === 0 ? "success" : "failed";
-  ws.finishedAt = new Date().toISOString();
-  await appendWorkstreamStatus(ws);
-  console.log(`Status updated to: ${ws.status}`);
+function shellEscape(s: string): string {
+  return "'" + s.replace(/'/g, "'\\''") + "'";
 }
 
 // ─── Action: View diff ───────────────────────────────────────────────────────
@@ -252,6 +260,7 @@ async function actionViewLogs(name: string, state: any) {
     name,
     logFile: ws.logFile,
     status: ws.status,
+    startedAt: ws.startedAt,
   });
 }
 
@@ -336,7 +345,7 @@ async function dispatchAction(action: DashboardAction, state: any, config: any):
     case "open-session": {
       const ws = state.currentRun?.workstreams?.[action.name];
       if (ws) await actionOpenSession(action.name, ws, state);
-      return false;
+      return true;
     }
 
     case "run": {
@@ -448,6 +457,12 @@ Dashboard keys: Enter=editor, d=diff, r=resume session, p=prompt agent,
             await openEditor(absPath, resolved);
             return true;
           },
+          onOpenSession: async (name: string): Promise<boolean> => {
+            const s = await loadState() ?? freshState;
+            const ws = s.currentRun?.workstreams?.[name];
+            if (!ws) return false;
+            return actionOpenSession(name, ws, s);
+          },
           onCreateWorkstream: async (name: string): Promise<boolean> => {
             try {
               await actionCreateWorkstream(name);

src/cli/diff.ts

@@ -39,7 +39,11 @@ Interactive viewer keys: j/k scroll, Tab switch panels, t toggle side-by-side,
           process.exit(1);
         }
         try {
-          const diff = await wt.diffBranch(`ws/${n}`);
+          const [branchDiff, uncommittedDiff] = await Promise.all([
+            wt.diffBranch(`ws/${n}`),
+            wt.diff(n),
+          ]);
+          const diff = branchDiff + uncommittedDiff;
           await openDiffViewer(n, diff);
         } catch (e: any) {
           console.error(`Error: ${e.message}`);
@@ -59,7 +63,11 @@ Interactive viewer keys: j/k scroll, Tab switch panels, t toggle side-by-side,
         if (ws.status !== "success" && ws.status !== "running") continue;
 
         try {
-          const diff = await wt.diffBranch(`ws/${n}`);
+          const [branchDiff, uncommittedDiff] = await Promise.all([
+            wt.diffBranch(`ws/${n}`),
+            wt.diff(n),
+          ]);
+          const diff = branchDiff + uncommittedDiff;
           if (diff.trim()) {
             console.log(`\x1b[1m=== ${n} ===\x1b[0m`);
             console.log(diff);

src/cli/list.ts

@@ -63,7 +63,7 @@ export async function listAction(configPath: string = "workstream.yaml") {
     }
 
     const commentsData = await loadComments(def.name);
-    const commentCount = commentsData.comments.length;
+    const commentCount = commentsData.comments.length + (commentsData.overallComment ? 1 : 0);
     const commentsStr = commentCount > 0
       ? `${A.brightYellow}${commentCount} comment${commentCount > 1 ? "s" : ""}${A.reset}`
       : "";
@@ -72,7 +72,7 @@ export async function listAction(configPath: string = "workstream.yaml") {
     if (hasWorktree) {
       const [info, stats] = await Promise.all([
         getBranchInfo(branch),
-        getDiffStats(branch),
+        getDiffStats(branch, worktreePath),
       ]);
 
       const syncPlain = info.ahead || info.behind ? `↑${info.ahead} ↓${info.behind}` : "·";

src/core/agent.ts

@@ -152,30 +152,9 @@ export class AgentAdapter {
 
       const exitCode = await proc.exited;
 
-      // Auto-commit any changes the agent made
-      if (exitCode === 0) {
-        await this.autoCommit(absWorkDir, appendLog);
-      }
-
       return { exitCode, sessionId };
     } catch (e: any) {
       throw new AgentError(`Agent failed: ${e.message}`);
     }
   }
-
-  private async autoCommit(
-    workDir: string,
-    appendLog: (data: string | Uint8Array) => Promise<void>,
-  ): Promise<void> {
-    const { $ } = await import("bun");
-
-    const status = await $`git -C ${workDir} status --porcelain`.quiet();
-    const changes = status.stdout.toString().trim();
-    if (!changes) return;
-
-    try {
-      await $`git -C ${workDir} add -A`.quiet();
-      await $`git -C ${workDir} commit -m "ws: apply agent changes"`.quiet();
-    } catch {}
-  }
 }

src/core/comments.ts

@@ -17,6 +17,7 @@ export interface ReviewComment {
 export interface WorkstreamComments {
   workstream: string;
   comments: ReviewComment[];
+  overallComment?: string;
   updatedAt: string;
 }
 
@@ -56,31 +57,44 @@ export async function deleteComment(name: string, index: number): Promise<Workst
 }
 
 export function formatCommentsAsPrompt(data: WorkstreamComments): string {
-  if (data.comments.length === 0) return "";
-
-  const sections = data.comments.map((c, i) => {
-    const typeLabel = c.lineType === "add" ? "added" : c.lineType === "remove" ? "removed" : "unchanged";
-    const loc = c.line
-      ? `${c.filePath}:${c.line} (${typeLabel} line, ${c.side ?? "new"} side)`
-      : c.filePath;
-
-    const parts = [`### Comment ${i + 1}: ${loc}`, c.text];
-
-    if (c.diffContext) {
-      parts.push("Surrounding diff context:");
-      parts.push("```diff", c.diffContext, "```");
-    } else if (c.lineContent) {
-      parts.push(`Line: \`${c.lineContent}\``);
-    }
-
-    return parts.join("\n");
-  });
-
-  return [
-    "I have the following review comments on the changes you made. Each comment includes the file, line number, whether the line was added/removed/unchanged, and the surrounding diff for context.",
-    "",
-    ...sections,
-    "",
-    "Please address each comment. Use the diff context to understand what changed and apply the fix to the correct location in the current working tree.",
-  ].join("\n");
+  const hasComments = data.comments.length > 0;
+  const hasOverall = !!data.overallComment;
+
+  if (!hasComments && !hasOverall) return "";
+
+  const parts: string[] = [];
+
+  if (hasOverall) {
+    parts.push("## Overall Comment", "", data.overallComment!, "");
+  }
+
+  if (hasComments) {
+    const sections = data.comments.map((c, i) => {
+      const typeLabel = c.lineType === "add" ? "added" : c.lineType === "remove" ? "removed" : "unchanged";
+      const loc = c.line
+        ? `${c.filePath}:${c.line} (${typeLabel} line, ${c.side ?? "new"} side)`
+        : c.filePath;
+
+      const inner = [`### Comment ${i + 1}: ${loc}`, c.text];
+
+      if (c.diffContext) {
+        inner.push("Surrounding diff context:");
+        inner.push("```diff", c.diffContext, "```");
+      } else if (c.lineContent) {
+        inner.push(`Line: \`${c.lineContent}\``);
+      }
+
+      return inner.join("\n");
+    });
+
+    parts.push(
+      "I have the following review comments on the changes you made. Each comment includes the file, line number, whether the line was added/removed/unchanged, and the surrounding diff for context.",
+      "",
+      ...sections,
+      "",
+      "Please address each comment. Use the diff context to understand what changed and apply the fix to the correct location in the current working tree.",
+    );
+  }
+
+  return parts.join("\n");
 }

src/core/worktree.ts

@@ -31,9 +31,71 @@ export class WorktreeManager {
         `Failed to create worktree for "${name}": ${e.stderr?.toString() ?? e.message}`
       );
     }
+
+    // Write a Claude Code pre-tool hook into the worktree that blocks any
+    // Read/Edit/Write targeting files outside this worktree.  This prevents
+    // agents (and interactive Claude sessions) from accidentally modifying the
+    // main repo or other worktrees.
+    await this.writeWorktreeGuard(path);
+
     return path;
   }
 
+  private async writeWorktreeGuard(worktreePath: string): Promise<void> {
+    const { mkdir, writeFile, chmod } = await import("fs/promises");
+    const { resolve } = await import("path");
+    const absPath = resolve(worktreePath);
+
+    // Guard script: receives tool input JSON on stdin, rejects file paths outside worktree
+    const guardScript = `#!/bin/bash
+# Auto-generated by ws — blocks file access outside this worktree
+WORKTREE="${absPath}"
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | grep -o '"file_path":"[^"]*"' | head -1 | sed 's/"file_path":"\\(.*\\)"/\\1/')
+if [ -z "$FILE_PATH" ]; then
+  exit 0
+fi
+# Resolve the path
+RESOLVED=$(cd "$WORKTREE" && realpath -m "$FILE_PATH" 2>/dev/null || echo "$FILE_PATH")
+case "$RESOLVED" in
+  "$WORKTREE"/*)
+    exit 0
+    ;;
+  *)
+    echo "BLOCKED: file_path \\"$FILE_PATH\\" is outside this worktree ($WORKTREE). Use relative paths or paths under the worktree." >&2
+    exit 2
+    ;;
+esac
+`;
+
+    const claudeDir = `${worktreePath}/.claude`;
+    await mkdir(claudeDir, { recursive: true });
+    const scriptPath = `${claudeDir}/worktree-guard.sh`;
+    await writeFile(scriptPath, guardScript);
+    await chmod(scriptPath, 0o755);
+
+    const settings = {
+      hooks: {
+        PreToolUse: [
+          {
+            matcher: "Edit|Write|Read",
+            hooks: [
+              {
+                type: "command",
+                command: `${resolve(scriptPath)}`,
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    await writeFile(
+      `${claudeDir}/settings.local.json`,
+      JSON.stringify(settings, null, 2) + "\n",
+    );
+  }
+
   async remove(name: string): Promise<void> {
     const path = `${TREES_DIR}/${name}`;
     const branch = `ws/${name}`;
@@ -67,7 +129,24 @@ export class WorktreeManager {
   async diff(name: string): Promise<string> {
     const path = `${TREES_DIR}/${name}`;
     const result = await $`git -C ${path} diff HEAD`.quiet();
-    return result.stdout.toString();
+    let diff = result.stdout.toString();
+
+    // Include untracked (new) files — git diff HEAD only shows tracked changes
+    const untracked = await $`git -C ${path} ls-files --others --exclude-standard`.quiet().catch(() => null);
+    if (untracked) {
+      const files = untracked.stdout.toString().trim().split("\n")
+        .filter(f => f && !f.startsWith(".claude/"));
+      for (const file of files) {
+        try {
+          await $`git -C ${path} diff --no-index -- /dev/null ${file}`.quiet();
+        } catch (e: any) {
+          // git diff --no-index exits 1 when files differ — expected for new files
+          if (e.stdout) diff += e.stdout.toString();
+        }
+      }
+    }
+
+    return diff;
   }
 
   async diffBranch(branch: string, baseBranch?: string): Promise<string> {