opencode-mad 1.0.0 → 1.0.2

package/plugins/mad-plugin.ts

@@ -46,10 +46,6 @@ function matchGlob(path: string, pattern: string): boolean {
 // Current version of opencode-mad
 const CURRENT_VERSION = "1.0.0"
 
-// Update notification state (shown only once per session)
-let updateNotificationShown = false
-let pendingUpdateMessage: string | null = null
-
 export const MADPlugin: Plugin = async ({ project, client, $, directory, worktree }) => {
   
   // Use the directory provided by OpenCode, fallback to process.cwd() for backwards compatibility
@@ -138,28 +134,6 @@ export const MADPlugin: Plugin = async ({ project, client, $, directory, worktre
     return { hasUpdate: false, current: CURRENT_VERSION, latest: CURRENT_VERSION }
   }
 
-  // Check for updates at plugin initialization and store message for first tool response
-  try {
-    const updateInfo = await checkForUpdates()
-    if (updateInfo.hasUpdate) {
-      pendingUpdateMessage = `🔄 **Update available!** opencode-mad ${updateInfo.current} → ${updateInfo.latest}\n   Run: \`npx opencode-mad install -g\`\n\n`
-      logEvent("info", "Update available", { current: updateInfo.current, latest: updateInfo.latest })
-    }
-  } catch (e) {
-    // Silent fail - don't break plugin initialization
-  }
-
-  /**
-   * Helper to get update notification (returns message only once)
-   */
-  const getUpdateNotification = (): string => {
-    if (pendingUpdateMessage && !updateNotificationShown) {
-      updateNotificationShown = true
-      return pendingUpdateMessage
-    }
-    return ""
-  }
-
   return {
     // Custom tools for MAD workflow
     tool: {
@@ -182,12 +156,12 @@ Each worktree has its own branch and working directory.`,
             // Validate inputs
             if (!branch || branch.trim() === "") {
               logEvent("error", "mad_worktree_create failed: empty branch name")
-              return getUpdateNotification() + "❌ Error: Branch name cannot be empty"
+              return "❌ Branch name required"
             }
             
             if (!task || task.trim() === "") {
               logEvent("error", "mad_worktree_create failed: empty task description")
-              return getUpdateNotification() + "❌ Error: Task description cannot be empty"
+              return "❌ Task description required"
             }
             
             const gitRoot = getGitRoot()
@@ -199,7 +173,7 @@ Each worktree has its own branch and working directory.`,
             // Check if worktree already exists
             if (existsSync(worktreePath)) {
               logEvent("warn", "Worktree already exists", { branch, path: worktreePath })
-              return getUpdateNotification() + `⚠️  Worktree already exists at ${worktreePath}\nUse a different branch name or clean up with mad_cleanup.`
+              return `⚠️ Worktree exists: ${sessionName}`
             }
 
             logEvent("info", "Creating worktree", { branch, baseBranch })
@@ -228,7 +202,7 @@ worktrees/
               mkdirSync(worktreeDir, { recursive: true })
             } catch (e: any) {
               logEvent("error", "Failed to create worktree directory", { error: e.message })
-              return getUpdateNotification() + `❌ Error creating worktree directory: ${e.message}`
+              return `❌ mkdir failed: ${e.message}`
             }
 
             // Check if branch exists
@@ -247,7 +221,7 @@ worktrees/
                 command: worktreeCmd,
                 error: worktreeResult.error 
               })
-              return getUpdateNotification() + `❌ Error creating git worktree: ${worktreeResult.error}`
+              return `❌ git worktree failed: ${worktreeResult.error}`
             }
 
             // Write task file using Node.js
@@ -266,16 +240,10 @@ ${task}
 
             logEvent("info", "Worktree created successfully", { branch, path: worktreePath })
 
-            return getUpdateNotification() + `✅ Worktree created successfully!
-- Path: ${worktreePath}
-- Branch: ${branch}
-- Base: ${baseBranch}
-- Task: ${task.substring(0, 100)}${task.length > 100 ? "..." : ""}
-
-The developer subagent can now work in this worktree using the Task tool.`
+            return `✅ Worktree: ${sessionName} (${branch})`
           } catch (e: any) {
             logEvent("error", "mad_worktree_create exception", { error: e.message, stack: e.stack })
-            return getUpdateNotification() + `❌ Unexpected error creating worktree: ${e.message}`
+            return `❌ Error: ${e.message}`
           }
         },
       }),
@@ -292,77 +260,36 @@ Shows which tasks are done, in progress, blocked, or have errors.`,
           const worktreeDir = join(gitRoot, "worktrees")
 
           if (!existsSync(worktreeDir)) {
-            return getUpdateNotification() + "No active MAD worktrees. Use mad_worktree_create to create one."
+            return "No worktrees"
           }
 
           const entries = readdirSync(worktreeDir)
           if (entries.length === 0) {
-            return getUpdateNotification() + "No active MAD worktrees. Use mad_worktree_create to create one."
+            return "No worktrees"
           }
 
-          let status = getUpdateNotification() + "# MAD Status Dashboard\n\n"
           let total = 0, done = 0, blocked = 0, errors = 0, wip = 0
+          let rows: string[] = []
 
           for (const entry of entries) {
             const wpath = join(worktreeDir, entry)
             if (!statSync(wpath).isDirectory()) continue
             total++
 
-            const taskFile = join(wpath, ".agent-task")
             const doneFile = join(wpath, ".agent-done")
             const blockedFile = join(wpath, ".agent-blocked")
             const errorFile = join(wpath, ".agent-error")
 
-            let statusIcon = "⏳"
-            let statusText = "IN PROGRESS"
-            let detail = ""
-
-            if (existsSync(doneFile)) {
-              statusIcon = "✅"
-              statusText = "DONE"
-              detail = readFileSync(doneFile, "utf-8").split("\n")[0]
-              done++
-            } else if (existsSync(blockedFile)) {
-              statusIcon = "🚫"
-              statusText = "BLOCKED"
-              detail = readFileSync(blockedFile, "utf-8").split("\n")[0]
-              blocked++
-            } else if (existsSync(errorFile)) {
-              statusIcon = "❌"
-              statusText = "ERROR"
-              detail = readFileSync(errorFile, "utf-8").split("\n")[0]
-              errors++
-            } else {
-              wip++
-            }
-
-            // Get task description
-            const task = existsSync(taskFile) 
-              ? readFileSync(taskFile, "utf-8").split("\n").filter(l => !l.startsWith("#") && l.trim()).join(" ").slice(0, 60)
-              : "No task file"
+            let icon = "⏳"
+            if (existsSync(doneFile)) { icon = "✅"; done++ }
+            else if (existsSync(blockedFile)) { icon = "🚫"; blocked++ }
+            else if (existsSync(errorFile)) { icon = "❌"; errors++ }
+            else { wip++ }
 
-            // Get commit count
-            let commits = "0"
-            try {
-              const baseBranch = getCurrentBranch()
-              const result = runCommand(`git log --oneline ${baseBranch}..HEAD`, wpath)
-              if (result.success) {
-                commits = result.output.split("\n").filter(l => l.trim()).length.toString()
-              }
-            } catch {}
-
-            status += `## ${statusIcon} ${entry}\n`
-            status += `- **Status:** ${statusText}\n`
-            status += `- **Task:** ${task}\n`
-            status += `- **Commits:** ${commits}\n`
-            if (detail) status += `- **Detail:** ${detail}\n`
-            status += `\n`
+            rows.push(`${icon} ${entry}`)
           }
 
-          status += `---\n`
-          status += `**Total:** ${total} | **Done:** ${done} | **WIP:** ${wip} | **Blocked:** ${blocked} | **Errors:** ${errors}\n`
-
-          return status
+          return `${rows.join("\n")}\n---\nTotal:${total} Done:${done} WIP:${wip} Blocked:${blocked} Err:${errors}`
         },
       }),
 
@@ -381,28 +308,23 @@ Returns the results and creates an error file if tests fail.`,
           const worktreePath = join(gitRoot, "worktrees", args.worktree)
 
           if (!existsSync(worktreePath)) {
-            return getUpdateNotification() + `Worktree not found: ${worktreePath}`
+            return `❌ Not found: ${args.worktree}`
           }
 
-          let results = getUpdateNotification() + `# Test Results for ${args.worktree}\n\n`
-          let hasError = false
+          let passed: string[] = []
+          let failed: string[] = []
           let errorMessages = ""
 
-          // Helper to run a check
           const doCheck = (label: string, cmd: string) => {
-            results += `## ${label}\n`
             const result = runCommand(cmd, worktreePath)
             if (result.success) {
-              results += `✅ Passed\n\`\`\`\n${result.output.slice(0, 500)}\n\`\`\`\n\n`
+              passed.push(label)
             } else {
-              hasError = true
-              const output = result.error || "Unknown error"
-              results += `❌ Failed\n\`\`\`\n${output.slice(0, 1000)}\n\`\`\`\n\n`
-              errorMessages += `${label} FAILED:\n${output}\n\n`
+              failed.push(label)
+              errorMessages += `${label}: ${result.error?.slice(0, 200)}\n`
             }
           }
 
-          // Detect project type and run checks
           const packageJson = join(worktreePath, "package.json")
           const goMod = join(worktreePath, "go.mod")
           const cargoToml = join(worktreePath, "Cargo.toml")
@@ -411,39 +333,29 @@ Returns the results and creates an error file if tests fail.`,
 
           if (existsSync(packageJson)) {
             const pkg = JSON.parse(readFileSync(packageJson, "utf-8"))
-            if (pkg.scripts?.lint) doCheck("Lint", "npm run lint")
-            if (pkg.scripts?.build) doCheck("Build", "npm run build")
-            if (pkg.scripts?.test) doCheck("Test", "npm test")
+            if (pkg.scripts?.lint) doCheck("lint", "npm run lint")
+            if (pkg.scripts?.build) doCheck("build", "npm run build")
+            if (pkg.scripts?.test) doCheck("test", "npm test")
           }
-
           if (existsSync(goMod)) {
-            doCheck("Go Build", "go build ./...")
-            doCheck("Go Test", "go test ./...")
+            doCheck("go-build", "go build ./...")
+            doCheck("go-test", "go test ./...")
           }
-
           if (existsSync(cargoToml)) {
-            doCheck("Cargo Check", "cargo check")
-            doCheck("Cargo Test", "cargo test")
+            doCheck("cargo-check", "cargo check")
+            doCheck("cargo-test", "cargo test")
           }
-
           if (existsSync(pyProject) || existsSync(requirements)) {
-            doCheck("Pytest", "pytest")
+            doCheck("pytest", "pytest")
           }
 
-          // Write error file if tests failed
-          if (hasError) {
+          if (failed.length > 0) {
             writeFileSync(join(worktreePath, ".agent-error"), errorMessages)
-            // Remove .agent-done since code is broken
             const doneFile = join(worktreePath, ".agent-done")
-            if (existsSync(doneFile)) {
-              unlinkSync(doneFile)
-            }
-            results += `\n---\n⚠️ Tests failed. Error details written to .agent-error. Use the fixer agent to resolve.`
-          } else {
-            results += `\n---\n✅ All checks passed!`
+            if (existsSync(doneFile)) unlinkSync(doneFile)
+            return `❌ Failed: ${failed.join(", ")}${passed.length ? ` | ✅ ${passed.join(", ")}` : ""}`
           }
-
-          return results
+          return `✅ All passed: ${passed.join(", ")}`
         },
       }),
 
@@ -464,22 +376,22 @@ Handles merge conflicts by reporting them.`,
           const branch = args.worktree
 
           if (!existsSync(worktreePath)) {
-            return getUpdateNotification() + `Worktree not found: ${worktreePath}`
+            return `❌ Not found: ${args.worktree}`
           }
 
           if (!existsSync(doneFile)) {
-            return getUpdateNotification() + `Cannot merge: worktree ${args.worktree} is not marked as done. Complete the task first.`
+            return `❌ Not done: ${args.worktree}`
           }
 
           const result = runCommand(`git merge --no-ff ${branch} --no-edit`, gitRoot)
           if (result.success) {
-            return getUpdateNotification() + `✅ Successfully merged ${branch}!\n\n${result.output}`
+            return `✅ Merged: ${branch}`
           } else {
-            const output = result.error || "Unknown error"
+            const output = result.error || ""
             if (output.includes("CONFLICT")) {
-              return getUpdateNotification() + `⚠️ Merge conflict detected!\n\n${output}\n\nResolve conflicts manually or use the fixer agent.`
+              return `⚠️ Conflict in ${branch}`
             }
-            return getUpdateNotification() + `❌ Merge failed:\n${output}`
+            return `❌ Merge failed: ${output.slice(0, 100)}`
           }
         },
       }),
@@ -500,19 +412,19 @@ Removes the worktree directory and prunes git worktree references.`,
           const doneFile = join(worktreePath, ".agent-done")
 
           if (!existsSync(worktreePath)) {
-            return getUpdateNotification() + `Worktree not found: ${worktreePath}`
+            return `❌ Not found: ${args.worktree}`
           }
 
           if (!args.force && !existsSync(doneFile)) {
-            return getUpdateNotification() + `Worktree ${args.worktree} is not marked as done. Use force=true to cleanup anyway.`
+            return `❌ Not done (use force=true)`
           }
 
           try {
             await $`git worktree remove ${worktreePath} --force`
             await $`git worktree prune`
-            return getUpdateNotification() + `✅ Cleaned up worktree: ${args.worktree}`
+            return `✅ Cleaned: ${args.worktree}`
           } catch (e: any) {
-            return getUpdateNotification() + `❌ Cleanup failed: ${e.message}`
+            return `❌ ${e.message}`
           }
         },
       }),
@@ -532,14 +444,13 @@ Use this when you've finished implementing the task in a worktree.`,
           const worktreePath = join(gitRoot, "worktrees", args.worktree)
 
           if (!existsSync(worktreePath)) {
-            return getUpdateNotification() + `Worktree not found: ${worktreePath}`
+            return `❌ Not found: ${args.worktree}`
           }
 
           await $`echo ${args.summary} > ${join(worktreePath, ".agent-done")}`
-          // Remove error/blocked files
           await $`rm -f ${join(worktreePath, ".agent-error")} ${join(worktreePath, ".agent-blocked")}`
 
-          return getUpdateNotification() + `✅ Marked ${args.worktree} as done: ${args.summary}`
+          return `✅ Done: ${args.worktree}`
         },
       }),
 
@@ -558,12 +469,12 @@ Use this when you cannot proceed due to missing information or dependencies.`,
           const worktreePath = join(gitRoot, "worktrees", args.worktree)
 
           if (!existsSync(worktreePath)) {
-            return getUpdateNotification() + `Worktree not found: ${worktreePath}`
+            return `❌ Not found: ${args.worktree}`
           }
 
           await $`echo ${args.reason} > ${join(worktreePath, ".agent-blocked")}`
 
-          return getUpdateNotification() + `🚫 Marked ${args.worktree} as blocked: ${args.reason}`
+          return `🚫 Blocked: ${args.worktree}`
         },
       }),
 
@@ -581,10 +492,10 @@ Use this to understand what needs to be done in a specific worktree.`,
           const taskFile = join(gitRoot, "worktrees", args.worktree, ".agent-task")
 
           if (!existsSync(taskFile)) {
-            return getUpdateNotification() + `Task file not found: ${taskFile}`
+            return `❌ No task: ${args.worktree}`
           }
 
-          return getUpdateNotification() + readFileSync(taskFile, "utf-8")
+          return readFileSync(taskFile, "utf-8")
         },
       }),
 
@@ -602,9 +513,9 @@ Creates structured logs in .mad-logs.jsonl for tracking the workflow.`,
         async execute(args, context) {
           try {
             await logEvent(args.level as "info" | "warn" | "error" | "debug", args.message, args.context)
-            return getUpdateNotification() + `📝 Logged [${args.level.toUpperCase()}]: ${args.message}`
+            return `✅ Logged`
           } catch (e: any) {
-            return getUpdateNotification() + `⚠️  Failed to write log: ${e.message}`
+            return `❌ ${e.message}`
           }
         },
       }),
@@ -613,8 +524,8 @@ Creates structured logs in .mad-logs.jsonl for tracking the workflow.`,
        * Visualize MAD workflow with ASCII art
        */
       mad_visualize: tool({
-        description: `Generate an ASCII art visualization of the MAD orchestration status.
-Shows progress, worktree statuses, timeline, and statistics in a beautiful dashboard.`,
+        description: `Generate a concise visualization of the MAD orchestration status.
+Shows progress and worktree statuses.`,
         args: {},
         async execute(args, context) {
           try {
@@ -622,115 +533,40 @@ Shows progress, worktree statuses, timeline, and statistics in a beautiful dashb
             const worktreeDir = join(gitRoot, "worktrees")
 
             if (!existsSync(worktreeDir)) {
-              return getUpdateNotification() + "No active MAD worktrees. Use mad_worktree_create to create one."
+              return "No worktrees"
             }
 
             const entries = readdirSync(worktreeDir)
             if (entries.length === 0) {
-              return getUpdateNotification() + "No active MAD worktrees. Use mad_worktree_create to create one."
+              return "No worktrees"
             }
 
             let total = 0, done = 0, blocked = 0, errors = 0, wip = 0
-            const worktrees: any[] = []
+            let rows: string[] = []
 
             for (const entry of entries) {
               const wpath = join(worktreeDir, entry)
               if (!statSync(wpath).isDirectory()) continue
               total++
 
-              const taskFile = join(wpath, ".agent-task")
               const doneFile = join(wpath, ".agent-done")
               const blockedFile = join(wpath, ".agent-blocked")
               const errorFile = join(wpath, ".agent-error")
 
-              let status = "IN PROGRESS"
               let icon = "⏳"
-              let detail = ""
-
-              if (existsSync(doneFile)) {
-                icon = "✅"
-                status = "DONE"
-                detail = readFileSync(doneFile, "utf-8").split("\n")[0]
-                done++
-              } else if (existsSync(blockedFile)) {
-                icon = "🚫"
-                status = "BLOCKED"
-                detail = readFileSync(blockedFile, "utf-8").split("\n")[0]
-                blocked++
-              } else if (existsSync(errorFile)) {
-                icon = "❌"
-                status = "ERROR"
-                detail = readFileSync(errorFile, "utf-8").split("\n")[0]
-                errors++
-              } else {
-                wip++
-              }
+              let status = "wip"
+              if (existsSync(doneFile)) { icon = "✅"; status = "done"; done++ }
+              else if (existsSync(blockedFile)) { icon = "🚫"; status = "blocked"; blocked++ }
+              else if (existsSync(errorFile)) { icon = "❌"; status = "error"; errors++ }
+              else { wip++ }
 
-              const task = existsSync(taskFile) 
-                ? readFileSync(taskFile, "utf-8").split("\n").filter(l => !l.startsWith("#") && l.trim()).join(" ").slice(0, 50)
-                : "No task file"
-
-              // Get commit count
-              const branch = entry.replace(/-/g, "/")
-              let commits = "0"
-              try {
-                const baseBranch = await getCurrentBranch()
-                const result = await runCommand(`git -C "${wpath}" log --oneline ${baseBranch}..HEAD 2>/dev/null | wc -l`)
-                commits = result.output.trim() || "0"
-              } catch {}
-
-              worktrees.push({ name: entry, status, icon, detail, task, commits })
+              rows.push(`${icon} ${entry} (${status})`)
             }
 
-            // Calculate progress
             const progress = total > 0 ? Math.round((done / total) * 100) : 0
-            const progressBar = "█".repeat(Math.floor(progress / 5)) + "░".repeat(20 - Math.floor(progress / 5))
-
-            // Build visualization
-            let output = getUpdateNotification() + `
-┌────────────────────────────────────────────────────────────────┐
-│              MAD ORCHESTRATION DASHBOARD                       │
-└────────────────────────────────────────────────────────────────┘
-
-📊 Progress: [${progressBar}] ${progress}% (${done}/${total} tasks complete)
-
-┌─ Worktree Status ─────────────────────────────────────────────┐
-│                                                                │
-`
-
-            for (const wt of worktrees) {
-              const statusPadded = wt.status.padEnd(15)
-              output += `│  ${wt.icon} ${wt.name.padEnd(35)} [${statusPadded}] │\n`
-              output += `│     └─ ${wt.commits} commits │ ${wt.task.padEnd(38)} │\n`
-              if (wt.detail) {
-                output += `│     └─ ${wt.detail.slice(0, 50).padEnd(50)} │\n`
-              }
-              output += `│                                                                │\n`
-            }
-
-            output += `└────────────────────────────────────────────────────────────────┘
-
-┌─ Statistics ──────────────────────────────────────────────────┐
-│                                                                │
-│  Total Worktrees:     ${total.toString().padEnd(40)} │
-│  ✅ Completed:        ${done} (${Math.round(done/total*100)}%)${' '.repeat(40 - done.toString().length - 7)} │
-│  ⏳ In Progress:      ${wip} (${Math.round(wip/total*100)}%)${' '.repeat(40 - wip.toString().length - 7)} │
-│  🚫 Blocked:          ${blocked} (${Math.round(blocked/total*100)}%)${' '.repeat(40 - blocked.toString().length - 7)} │
-│  ❌ Errors:           ${errors} (${Math.round(errors/total*100)}%)${' '.repeat(40 - errors.toString().length - 7)} │
-│                                                                │
-└────────────────────────────────────────────────────────────────┘
-`
-
-            if (blocked > 0 || errors > 0) {
-              output += `\n💡 Next Actions:\n`
-              if (errors > 0) output += `  • Fix ${errors} errored worktree(s) (check .agent-error files)\n`
-              if (blocked > 0) output += `  • Unblock ${blocked} blocked worktree(s)\n`
-              if (done > 0) output += `  • Ready to merge: ${worktrees.filter(w => w.status === "DONE").map(w => w.name).join(", ")}\n`
-            }
-
-            return output
+            return `Progress: ${progress}% (${done}/${total})\n${rows.join("\n")}`
           } catch (e: any) {
-            return getUpdateNotification() + `❌ Error generating visualization: ${e.message}`
+            return `❌ ${e.message}`
           }
         },
       }),
@@ -745,23 +581,12 @@ Returns the current version, latest version, and whether an update is available.
         async execute(args, context) {
           try {
             const updateInfo = await checkForUpdates()
-            
             if (updateInfo.hasUpdate) {
-              return getUpdateNotification() + `🔄 Update available!
-
-Current version: ${updateInfo.current}
-Latest version:  ${updateInfo.latest}
-
-To update, run:
-  npx opencode-mad install -g`
-            } else {
-              return getUpdateNotification() + `✅ You're up to date!
-
-Current version: ${updateInfo.current}
-Latest version:  ${updateInfo.latest}`
+              return `🔄 Update: ${updateInfo.current} → ${updateInfo.latest}`
             }
+            return `✅ Up to date: ${updateInfo.current}`
           } catch (e: any) {
-            return getUpdateNotification() + `❌ Failed to check for updates: ${e.message}`
+            return `❌ ${e.message}`
           }
         },
       }),
@@ -780,108 +605,45 @@ If CI fails, returns error details for the orchestrator to spawn a fixer.`,
         async execute(args, context) {
           try {
             const gitRoot = getGitRoot()
-            let report = getUpdateNotification() + "# Push & CI Watch\n\n"
             
-            // 1. Check if we have a remote
             const remoteResult = runCommand("git remote get-url origin", gitRoot)
             if (!remoteResult.success) {
-              return report + "⚠️ No remote 'origin' configured. Skipping push."
+              return "⚠️ No remote configured"
             }
             
-            // 2. Get current branch
             const branch = getCurrentBranch()
-            report += `📍 Branch: \`${branch}\`\n\n`
-            
-            // 3. Check if upstream exists, if not set it
             const upstreamResult = runCommand(`git rev-parse --abbrev-ref ${branch}@{upstream}`, gitRoot)
-            
-            // 4. Push
-            report += "## 🚀 Pushing to remote...\n"
-            const pushCmd = upstreamResult.success 
-              ? "git push"
-              : `git push -u origin ${branch}`
+            const pushCmd = upstreamResult.success ? "git push" : `git push -u origin ${branch}`
             
             const pushResult = runCommand(pushCmd, gitRoot)
             if (!pushResult.success) {
-              return report + `❌ Push failed:\n\`\`\`\n${pushResult.error}\n\`\`\`\n\nFix the issue and try again.`
+              return `❌ Push failed: ${pushResult.error?.slice(0, 100)}`
             }
-            report += "✅ Push successful!\n\n"
             
-            // 5. Check if gh CLI is available
             const ghCheck = runCommand("gh --version", gitRoot)
             if (!ghCheck.success) {
-              return report + "⚠️ GitHub CLI (gh) not installed. Cannot watch CI.\n\nInstall with: https://cli.github.com/"
+              return "✅ Pushed (no gh CLI for CI)"
             }
             
-            // 6. Check for running/pending workflow runs
-            report += "## 🔍 Checking for CI workflows...\n"
             const runsResult = runCommand(
-              `gh run list --branch ${branch} --limit 1 --json databaseId,status,conclusion,name,event`,
+              `gh run list --branch ${branch} --limit 1 --json databaseId,status,conclusion,name`,
               gitRoot
             )
             
-            if (!runsResult.success) {
-              return report + "⚠️ Could not check CI status. You may not be authenticated with `gh auth login`."
-            }
-            
             let runs: any[] = []
-            try {
-              runs = JSON.parse(runsResult.output)
-            } catch {
-              return report + "⚠️ No CI workflows found for this repository.\n\n✅ Push complete (no CI to watch)."
-            }
+            try { runs = JSON.parse(runsResult.output) } catch { return "✅ Pushed (no CI)" }
+            if (runs.length === 0) return "✅ Pushed (no CI)"
             
-            if (runs.length === 0) {
-              return report + "ℹ️ No CI workflows found for this branch.\n\n✅ Push complete!"
+            const run = runs[0]
+            if (run.status === "completed") {
+              return run.conclusion === "success" ? "✅ Pushed, CI passed" : `❌ CI failed: ${run.name}`
             }
             
-            const latestRun = runs[0]
-            report += `Found workflow: **${latestRun.name}** (${latestRun.event})\n\n`
-            
-            // 7. If already completed, just report status
-            if (latestRun.status === "completed") {
-              if (latestRun.conclusion === "success") {
-                return report + `✅ CI already passed! (${latestRun.name})\n\n🎉 All done!`
-              } else {
-                report += `❌ CI failed with conclusion: ${latestRun.conclusion}\n\n`
-                report += "Use `gh run view --log-failed` to see error details.\n"
-                if (args.createFixWorktree) {
-                  report += "\n💡 **Suggestion:** Create a `fix-ci` worktree to fix the CI errors."
-                }
-                return report
-              }
-            }
-            
-            // 8. Watch the CI run in real-time
-            report += "## ⏳ Watching CI...\n"
-            report += `Running: \`gh run watch ${latestRun.databaseId}\`\n\n`
-            
-            // Use gh run watch (this blocks until complete)
-            const watchResult = runCommand(
-              `gh run watch ${latestRun.databaseId} --exit-status`,
-              gitRoot
-            )
-            
-            if (watchResult.success) {
-              return report + `✅ CI passed!\n\n\`\`\`\n${watchResult.output.slice(-500)}\n\`\`\`\n\n🎉 All done!`
-            } else {
-              report += `❌ CI failed!\n\n\`\`\`\n${(watchResult.error || watchResult.output).slice(-1000)}\n\`\`\`\n\n`
-              
-              // Get failed logs
-              const logsResult = runCommand(`gh run view ${latestRun.databaseId} --log-failed`, gitRoot)
-              if (logsResult.success && logsResult.output) {
-                report += `### Failed logs:\n\`\`\`\n${logsResult.output.slice(-2000)}\n\`\`\`\n\n`
-              }
-              
-              if (args.createFixWorktree) {
-                report += "💡 **Recommendation:** Create a `fix-ci` worktree to fix these errors."
-              }
-              
-              return report
-            }
+            const watchResult = runCommand(`gh run watch ${run.databaseId} --exit-status`, gitRoot)
+            return watchResult.success ? "✅ Pushed, CI passed" : `❌ CI failed: ${run.name}`
           } catch (e: any) {
             logEvent("error", "mad_push_and_watch exception", { error: e.message })
-            return getUpdateNotification() + `❌ Error: ${e.message}`
+            return `❌ ${e.message}`
           }
         }
       }),
@@ -891,25 +653,18 @@ If CI fails, returns error details for the orchestrator to spawn a fixer.`,
        */
       mad_final_check: tool({
         description: `Run global build/lint checks on the main project after all merges.
-Compares errors against files modified during the MAD session to distinguish:
-- Session errors: caused by changes made during this session
-- Pre-existing errors: already present before the session started
-
-Use this at the end of the MAD workflow to ensure code quality.`,
+Compares errors against files modified during the MAD session.`,
         args: {
-          baseCommit: tool.schema.string().optional().describe("The commit SHA from before the MAD session started. If not provided, will try to detect from reflog."),
+          baseCommit: tool.schema.string().optional().describe("The commit SHA from before the MAD session started."),
         },
         async execute(args, context) {
           try {
             const gitRoot = getGitRoot()
             
-            // 1. Determine base commit for comparison
             let baseCommit = args.baseCommit
             if (!baseCommit) {
-              // Try to find the commit before MAD session started (look for last commit before worktrees were created)
               const reflogResult = runCommand('git reflog --format="%H %gs" -n 50', gitRoot)
               if (reflogResult.success) {
-                // Find first commit that's not a merge from a MAD branch
                 const lines = reflogResult.output.split('\n')
                 for (const line of lines) {
                   if (!line.includes('merge') || (!line.includes('feat-') && !line.includes('fix-'))) {
@@ -918,233 +673,80 @@ Use this at the end of the MAD workflow to ensure code quality.`,
                   }
                 }
               }
-              if (!baseCommit) {
-                baseCommit = 'HEAD~10' // Fallback
-              }
+              if (!baseCommit) baseCommit = 'HEAD~10'
             }
             
-            // 2. Get list of files modified during session
             const diffResult = runCommand(`git diff ${baseCommit}..HEAD --name-only`, gitRoot)
             const modifiedFiles = diffResult.success 
               ? diffResult.output.split('\n').filter(f => f.trim()).map(f => f.trim())
               : []
             
-            let report = getUpdateNotification() + `# Final Project Check\n\n`
-            report += `📊 **Session Summary:**\n`
-            report += `- Base commit: \`${baseCommit.substring(0, 8)}\`\n`
-            report += `- Files modified: ${modifiedFiles.length}\n\n`
-            
-            // 3. Detect project type and run checks
             const packageJson = join(gitRoot, "package.json")
             const goMod = join(gitRoot, "go.mod")
             const cargoToml = join(gitRoot, "Cargo.toml")
             const pyProject = join(gitRoot, "pyproject.toml")
             
-            interface CheckError {
-              file: string
-              line?: number
-              message: string
-              isSessionError: boolean
-            }
-            
-            const allErrors: CheckError[] = []
-            let checksRun = 0
+            let passed: string[] = []
+            let failed: string[] = []
+            let sessionErrors = 0
+            let preExistingErrors = 0
             
-            // Helper to parse errors and categorize them
-            const parseAndCategorize = (output: string, checkName: string) => {
-              // Common patterns for file:line:message
-              const patterns = [
-                /^(.+?):(\d+):\d*:?\s*(.+)$/gm,  // file:line:col: message
-                /^(.+?)\((\d+),\d+\):\s*(.+)$/gm, // file(line,col): message (TypeScript)
-                /^\s*(.+?):(\d+)\s+(.+)$/gm,      // file:line message
-              ]
-              
-              for (const pattern of patterns) {
-                let match
-                while ((match = pattern.exec(output)) !== null) {
-                  const file = match[1].trim().replace(/\\/g, '/')
-                  const line = parseInt(match[2])
-                  const message = match[3].trim()
-                  
-                  // Check if this file was modified during session
-                  const isSessionError = modifiedFiles.some(mf => 
-                    file.endsWith(mf) || mf.endsWith(file) || file.includes(mf) || mf.includes(file)
-                  )
-                  
-                  allErrors.push({ file, line, message, isSessionError })
+            const runCheck = (name: string, cmd: string) => {
+              const result = runCommand(`${cmd} 2>&1`, gitRoot)
+              if (result.success) {
+                passed.push(name)
+              } else {
+                failed.push(name)
+                // Count errors in modified files vs pre-existing
+                const output = result.error || result.output
+                const lines = output.split('\n')
+                for (const line of lines) {
+                  const match = line.match(/^(.+?):(\d+)/)
+                  if (match) {
+                    const file = match[1].replace(/\\/g, '/')
+                    if (modifiedFiles.some(mf => file.includes(mf) || mf.includes(file))) {
+                      sessionErrors++
+                    } else {
+                      preExistingErrors++
+                    }
+                  }
                 }
               }
             }
             
-            // Run checks based on project type
             if (existsSync(packageJson)) {
               const pkg = JSON.parse(readFileSync(packageJson, "utf-8"))
-              
-              if (pkg.scripts?.lint) {
-                checksRun++
-                report += `## 🔍 Lint Check\n`
-                const lintResult = runCommand("npm run lint 2>&1", gitRoot)
-                if (lintResult.success) {
-                  report += `✅ Lint passed\n\n`
-                } else {
-                  report += `❌ Lint failed\n`
-                  parseAndCategorize(lintResult.error || lintResult.output, "lint")
-                }
-              }
-              
-              if (pkg.scripts?.build) {
-                checksRun++
-                report += `## 🔨 Build Check\n`
-                const buildResult = runCommand("npm run build 2>&1", gitRoot)
-                if (buildResult.success) {
-                  report += `✅ Build passed\n\n`
-                } else {
-                  report += `❌ Build failed\n`
-                  parseAndCategorize(buildResult.error || buildResult.output, "build")
-                }
-              }
-              
-              if (pkg.scripts?.typecheck || pkg.scripts?.["type-check"]) {
-                checksRun++
-                const cmd = pkg.scripts?.typecheck ? "npm run typecheck" : "npm run type-check"
-                report += `## 📝 TypeCheck\n`
-                const tcResult = runCommand(`${cmd} 2>&1`, gitRoot)
-                if (tcResult.success) {
-                  report += `✅ TypeCheck passed\n\n`
-                } else {
-                  report += `❌ TypeCheck failed\n`
-                  parseAndCategorize(tcResult.error || tcResult.output, "typecheck")
-                }
-              }
+              if (pkg.scripts?.lint) runCheck("lint", "npm run lint")
+              if (pkg.scripts?.build) runCheck("build", "npm run build")
+              if (pkg.scripts?.typecheck) runCheck("typecheck", "npm run typecheck")
             }
-            
             if (existsSync(goMod)) {
-              checksRun++
-              report += `## 🔨 Go Build\n`
-              const goBuild = runCommand("go build ./... 2>&1", gitRoot)
-              if (goBuild.success) {
-                report += `✅ Go build passed\n\n`
-              } else {
-                parseAndCategorize(goBuild.error || goBuild.output, "go build")
-              }
-              
-              checksRun++
-              report += `## 🔍 Go Vet\n`
-              const goVet = runCommand("go vet ./... 2>&1", gitRoot)
-              if (goVet.success) {
-                report += `✅ Go vet passed\n\n`
-              } else {
-                parseAndCategorize(goVet.error || goVet.output, "go vet")
-              }
+              runCheck("go-build", "go build ./...")
+              runCheck("go-vet", "go vet ./...")
             }
-            
             if (existsSync(cargoToml)) {
-              checksRun++
-              report += `## 🔨 Cargo Check\n`
-              const cargoCheck = runCommand("cargo check 2>&1", gitRoot)
-              if (cargoCheck.success) {
-                report += `✅ Cargo check passed\n\n`
-              } else {
-                parseAndCategorize(cargoCheck.error || cargoCheck.output, "cargo")
-              }
-              
-              checksRun++
-              report += `## 🔍 Cargo Clippy\n`
-              const clippy = runCommand("cargo clippy 2>&1", gitRoot)
-              if (clippy.success) {
-                report += `✅ Clippy passed\n\n`
-              } else {
-                parseAndCategorize(clippy.error || clippy.output, "clippy")
-              }
+              runCheck("cargo", "cargo check")
             }
-            
             if (existsSync(pyProject)) {
-              checksRun++
-              report += `## 🔍 Python Lint (ruff/flake8)\n`
-              let pyLint = runCommand("ruff check . 2>&1", gitRoot)
-              if (!pyLint.success && pyLint.error?.includes("not found")) {
-                pyLint = runCommand("flake8 . 2>&1", gitRoot)
-              }
-              if (pyLint.success) {
-                report += `✅ Python lint passed\n\n`
-              } else {
-                parseAndCategorize(pyLint.error || pyLint.output, "python lint")
-              }
-              
-              checksRun++
-              report += `## 📝 Python Type Check (mypy)\n`
-              const mypy = runCommand("mypy . 2>&1", gitRoot)
-              if (mypy.success) {
-                report += `✅ Mypy passed\n\n`
-              } else {
-                parseAndCategorize(mypy.error || mypy.output, "mypy")
-              }
-            }
-            
-            if (checksRun === 0) {
-              report += `⚠️ No build/lint scripts detected in this project.\n`
-              report += `Supported: package.json (npm), go.mod, Cargo.toml, pyproject.toml\n`
-              logEvent("warn", "mad_final_check: no checks detected", { gitRoot })
-              return report
-            }
-            
-            // 4. Categorize and report errors
-            const sessionErrors = allErrors.filter(e => e.isSessionError)
-            const preExistingErrors = allErrors.filter(e => !e.isSessionError)
-            
-            report += `---\n\n## 📋 Error Summary\n\n`
-            
-            if (allErrors.length === 0) {
-              report += `🎉 **All checks passed!** No errors detected.\n`
-              logEvent("info", "mad_final_check: all checks passed", { checksRun })
-              return report
+              runCheck("ruff", "ruff check .")
             }
             
-            if (sessionErrors.length > 0) {
-              report += `### ❌ Session Errors (${sessionErrors.length})\n`
-              report += `*These errors are in files modified during this session:*\n\n`
-              for (const err of sessionErrors.slice(0, 10)) {
-                report += `- \`${err.file}${err.line ? `:${err.line}` : ''}\`: ${err.message.substring(0, 100)}\n`
-              }
-              if (sessionErrors.length > 10) {
-                report += `- ... and ${sessionErrors.length - 10} more\n`
-              }
-              report += `\n`
+            if (passed.length === 0 && failed.length === 0) {
+              return "⚠️ No checks found"
             }
             
-            if (preExistingErrors.length > 0) {
-              report += `### ⚠️ Pre-existing Errors (${preExistingErrors.length})\n`
-              report += `*These errors are NOT caused by this session - they existed before:*\n\n`
-              for (const err of preExistingErrors.slice(0, 10)) {
-                report += `- \`${err.file}${err.line ? `:${err.line}` : ''}\`: ${err.message.substring(0, 100)}\n`
-              }
-              if (preExistingErrors.length > 10) {
-                report += `- ... and ${preExistingErrors.length - 10} more\n`
-              }
-              report += `\n`
-              report += `💡 **These pre-existing errors are not your fault!**\n`
-              report += `Would you like me to create a worktree to fix them? Just say "fix pre-existing errors".\n`
-            }
-            
-            // 5. Final verdict
-            report += `\n---\n\n`
-            if (sessionErrors.length > 0) {
-              report += `⚠️ **Action required:** Fix the ${sessionErrors.length} session error(s) before considering this session complete.\n`
-            } else if (preExistingErrors.length > 0) {
-              report += `✅ **Session successful!** Your changes introduced no new errors.\n`
-              report += `The ${preExistingErrors.length} pre-existing error(s) can be fixed separately if desired.\n`
+            if (failed.length === 0) {
+              return `✅ All passed: ${passed.join(", ")}`
             }
             
-            logEvent("info", "mad_final_check completed", { 
-              checksRun, 
-              sessionErrors: sessionErrors.length, 
-              preExistingErrors: preExistingErrors.length 
-            })
-            
-            return report
+            let result = `❌ Failed: ${failed.join(", ")}`
+            if (passed.length) result += ` | ✅ ${passed.join(", ")}`
+            if (sessionErrors) result += ` | Session errors: ${sessionErrors}`
+            if (preExistingErrors) result += ` | Pre-existing: ${preExistingErrors}`
+            return result
           } catch (e: any) {
-            logEvent("error", "mad_final_check exception", { error: e.message, stack: e.stack })
-            return getUpdateNotification() + `❌ Error running final check: ${e.message}`
+            logEvent("error", "mad_final_check exception", { error: e.message })
+            return `❌ ${e.message}`
           }
         },
       }),
@@ -1187,7 +789,7 @@ The plugin will then BLOCK any unauthorized actions.`,
           
           logEvent("info", `Registered agent permissions`, { sessionID, agentType, canEdit, worktree })
           
-          return getUpdateNotification() + `✅ Agent registered: ${agentType} (canEdit: ${canEdit}, worktree: ${worktree || 'none'})`
+          return `✅ Registered: ${agentType}`
         }
       }),
 
@@ -1203,39 +805,18 @@ Use mode 'full' for complete project scan, 'targeted' for task-specific analysis
           paths: tool.schema.array(tool.schema.string()).optional().describe("Specific paths to analyze"),
         },
         async execute(args, context) {
-          const { mode, focus, paths } = args
+          const { mode, focus } = args
           const gitRoot = getGitRoot()
           
-          let report = `# Codebase Analysis Report\n\n`
-          report += `**Mode:** ${mode}\n`
-          report += `**Date:** ${new Date().toISOString()}\n\n`
-          
-          // Collecter les informations de base
           const structure = runCommand('find . -type f -name "*.ts" -o -name "*.js" -o -name "*.json" | grep -v node_modules | head -50', gitRoot)
           const packageJsonPath = join(gitRoot, 'package.json')
-          const packageJson = existsSync(packageJsonPath) 
-            ? JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
-            : null
-          
-          report += `## Project Structure\n\`\`\`\n${structure.output}\n\`\`\`\n\n`
-          
-          if (packageJson) {
-            report += `## Dependencies\n`
-            report += `- **Name:** ${packageJson.name}\n`
-            report += `- **Version:** ${packageJson.version}\n`
-            report += `- **Dependencies:** ${Object.keys(packageJson.dependencies || {}).length}\n`
-            report += `- **DevDependencies:** ${Object.keys(packageJson.devDependencies || {}).length}\n\n`
-          }
+          const pkg = existsSync(packageJsonPath) ? JSON.parse(readFileSync(packageJsonPath, 'utf-8')) : null
           
-          if (mode === 'targeted' && focus) {
-            report += `## Targeted Analysis: ${focus}\n`
-            // Chercher les fichiers pertinents
-            const relevantFiles = runCommand(`grep -rl "${focus}" --include="*.ts" --include="*.js" . | grep -v node_modules | head -20`, gitRoot)
-            report += `### Relevant Files\n\`\`\`\n${relevantFiles.output || 'No files found'}\n\`\`\`\n`
-          }
+          let info = `Files: ${structure.output.split('\n').length}`
+          if (pkg) info += ` | Deps: ${Object.keys(pkg.dependencies || {}).length}`
           
           logEvent("info", "Codebase analysis completed", { mode, focus })
-          return getUpdateNotification() + report
+          return `✅ Analyzed: ${info}`
         }
       }),
 
@@ -1250,13 +831,8 @@ Use mode 'full' for complete project scan, 'targeted' for task-specific analysis
         async execute(args) {
           const existed = agentPermissions.has(args.sessionID)
           agentPermissions.delete(args.sessionID)
-          
-          if (existed) {
-            logEvent("info", `Unregistered agent`, { sessionID: args.sessionID })
-            return `✅ Agent unregistered: ${args.sessionID}`
-          } else {
-            return `⚠️ Agent was not registered: ${args.sessionID}`
-          }
+          logEvent("info", `Unregistered agent`, { sessionID: args.sessionID })
+          return existed ? `✅ Unregistered` : `⚠️ Not found`
         }
       }),
 
@@ -1291,7 +867,7 @@ The plan will be available for the orchestrator to present to the user.`,
           // Log pour debugging
           logEvent("info", "Development plan created", { planName, taskCount: tasks.length })
           
-          return getUpdateNotification() + `✅ Plan '${planName}' created with ${tasks.length} tasks.\n\n${plan}`
+          return `✅ Plan: ${planName} (${tasks.length} tasks)`
         }
       }),
 
@@ -1320,54 +896,18 @@ Called by the Reviewer agent after analyzing the code.`,
           const worktreePath = join(gitRoot, "worktrees", worktree)
           
           if (!existsSync(worktreePath)) {
-            return getUpdateNotification() + `❌ Worktree not found: ${worktreePath}`
+            return `❌ Not found: ${worktree}`
           }
           
-          // Créer le rapport de review
-          let report = `# Code Review: ${worktree}\n\n`
-          report += `**Verdict:** ${verdict === 'approved' ? '✅ APPROVED' : verdict === 'changes_requested' ? '⚠️ CHANGES REQUESTED' : '❌ REJECTED'}\n\n`
-          report += `## Summary\n${summary}\n\n`
+          const icon = verdict === 'approved' ? '✅' : verdict === 'changes_requested' ? '⚠️' : '❌'
+          const issueCount = issues?.length || 0
           
-          if (positives && positives.length > 0) {
-            report += `## Positives 👍\n`
-            positives.forEach(p => report += `- ${p}\n`)
-            report += '\n'
-          }
-          
-          if (issues && issues.length > 0) {
-            report += `## Issues Found\n`
-            const critical = issues.filter(i => i.severity === 'critical')
-            const major = issues.filter(i => i.severity === 'major')
-            const minor = issues.filter(i => i.severity === 'minor')
-            
-            if (critical.length > 0) {
-              report += `### 🚨 Critical (${critical.length})\n`
-              critical.forEach(i => {
-                report += `- **${i.file}${i.line ? `:${i.line}` : ''}** - ${i.message}\n`
-                if (i.suggestion) report += `  → Suggestion: ${i.suggestion}\n`
-              })
-            }
-            if (major.length > 0) {
-              report += `### ⚠️ Major (${major.length})\n`
-              major.forEach(i => {
-                report += `- **${i.file}${i.line ? `:${i.line}` : ''}** - ${i.message}\n`
-                if (i.suggestion) report += `  → Suggestion: ${i.suggestion}\n`
-              })
-            }
-            if (minor.length > 0) {
-              report += `### 💡 Minor (${minor.length})\n`
-              minor.forEach(i => {
-                report += `- **${i.file}${i.line ? `:${i.line}` : ''}** - ${i.message}\n`
-              })
-            }
-          }
+          // Save report
+          writeFileSync(join(worktreePath, '.agent-review'), `${verdict}: ${summary}`)
           
-          // Sauvegarder le rapport dans le worktree
-          writeFileSync(join(worktreePath, '.agent-review'), report)
+          logEvent("info", "Code review submitted", { worktree, verdict, issueCount })
           
-          logEvent("info", "Code review submitted", { worktree, verdict, issueCount: issues?.length || 0 })
-          
-          return getUpdateNotification() + report
+          return `${icon} Review: ${verdict} (${issueCount} issues)`
         }
       }),
 
@@ -1401,51 +941,22 @@ Called by the Security agent after scanning for vulnerabilities.`,
           const { target, riskLevel, summary, vulnerabilities, dependencyIssues } = args
           const gitRoot = getGitRoot()
           
-          let report = `# Security Scan Report: ${target}\n\n`
-          report += `**Risk Level:** ${riskLevel === 'critical' ? '🚨 CRITICAL' : riskLevel === 'high' ? '🔴 HIGH' : riskLevel === 'medium' ? '🟡 MEDIUM' : '🟢 LOW'}\n`
-          report += `**Date:** ${new Date().toISOString()}\n\n`
-          report += `## Summary\n${summary}\n\n`
-          
-          if (vulnerabilities && vulnerabilities.length > 0) {
-            report += `## Vulnerabilities (${vulnerabilities.length})\n\n`
-            vulnerabilities.forEach(v => {
-              const icon = v.severity === 'critical' ? '🚨' : v.severity === 'high' ? '🔴' : v.severity === 'medium' ? '🟡' : '🟢'
-              report += `### ${icon} [${v.id}] ${v.type}\n`
-              report += `**Severity:** ${v.severity.toUpperCase()}\n`
-              if (v.file) report += `**Location:** ${v.file}${v.line ? `:${v.line}` : ''}\n`
-              report += `**Description:** ${v.description}\n`
-              report += `**Remediation:** ${v.remediation}\n\n`
-            })
-          }
-          
-          if (dependencyIssues && dependencyIssues.length > 0) {
-            report += `## Vulnerable Dependencies (${dependencyIssues.length})\n\n`
-            report += `| Package | Severity | CVE | Fix |\n`
-            report += `|---------|----------|-----|-----|\n`
-            dependencyIssues.forEach(d => {
-              report += `| ${d.package} | ${d.severity} | ${d.cve || 'N/A'} | ${d.fix} |\n`
-            })
-            report += '\n'
-          }
-          
-          // Verdict
+          const vulnCount = vulnerabilities?.length || 0
+          const depCount = dependencyIssues?.length || 0
           const canMerge = riskLevel === 'low' || (riskLevel === 'medium' && (!vulnerabilities || vulnerabilities.filter(v => v.severity === 'critical' || v.severity === 'high').length === 0))
-          report += `## Verdict\n`
-          report += canMerge 
-            ? `✅ **PASS** - No critical security issues blocking merge.\n`
-            : `❌ **FAIL** - Critical security issues must be resolved before merge.\n`
           
-          // Sauvegarder si c'est un worktree
+          // Save if worktree
           if (target !== 'main') {
             const worktreePath = join(gitRoot, "worktrees", target)
             if (existsSync(worktreePath)) {
-              writeFileSync(join(worktreePath, '.agent-security'), report)
+              writeFileSync(join(worktreePath, '.agent-security'), `${riskLevel}: ${summary}`)
             }
           }
           
-          logEvent("info", "Security scan completed", { target, riskLevel, vulnCount: vulnerabilities?.length || 0 })
+          logEvent("info", "Security scan completed", { target, riskLevel, vulnCount })
           
-          return getUpdateNotification() + report
+          const icon = canMerge ? '✅' : '❌'
+          return `${icon} Security: ${riskLevel} (${vulnCount} vulns, ${depCount} deps)`
         }
       }),
     },
@@ -1479,24 +990,22 @@ Called by the Security agent after scanning for vulnerabilities.`,
         if (['edit', 'write', 'patch', 'multiedit'].includes(toolName)) {
           if (!perms.canEdit) {
             logEvent("warn", `BLOCKED: ${perms.type} tried to use ${toolName}`, { sessionID: input.sessionID })
-            throw new Error(`🚫 BLOCKED: Agent type '${perms.type}' cannot use '${toolName}' tool. This agent is READ-ONLY.`)
+            throw new Error(`🚫 ${perms.type} is read-only`)
           }
           
           // 2. Check path if allowedPaths is defined
           const targetPath = args.filePath || args.file_path || args.path
           if (targetPath) {
-            // Check denied paths
             if (perms.deniedPaths.some((p: string) => targetPath.includes(p) || matchGlob(targetPath, p))) {
               logEvent("warn", `BLOCKED: ${perms.type} tried to edit denied path`, { sessionID: input.sessionID, path: targetPath })
-              throw new Error(`🚫 BLOCKED: Cannot edit '${targetPath}' - this path is explicitly denied for this agent.`)
+              throw new Error(`🚫 Path denied: ${basename(targetPath)}`)
             }
             
-            // Check allowed paths (if defined)
             if (perms.allowedPaths && perms.allowedPaths.length > 0) {
               const isAllowed = perms.allowedPaths.some((p: string) => targetPath.includes(p) || matchGlob(targetPath, p))
               if (!isAllowed) {
-                logEvent("warn", `BLOCKED: ${perms.type} tried to edit outside allowed paths`, { sessionID: input.sessionID, path: targetPath, allowedPaths: perms.allowedPaths })
-                throw new Error(`🚫 BLOCKED: Cannot edit '${targetPath}' - outside allowed paths: ${perms.allowedPaths.join(', ')}`)
+                logEvent("warn", `BLOCKED: ${perms.type} tried to edit outside allowed paths`, { sessionID: input.sessionID, path: targetPath })
+                throw new Error(`🚫 Outside allowed paths: ${basename(targetPath)}`)
               }
             }
           }
@@ -1506,22 +1015,22 @@ Called by the Security agent after scanning for vulnerabilities.`,
         if (toolName === 'bash' && perms && !perms.canEdit) {
           const cmd = args.command || ''
           const dangerousPatterns = [
-            /\becho\s+.*>/,      // echo > file
-            /\bcat\s+.*>/,       // cat > file
-            /\brm\s+/,           // rm
-            /\bmv\s+/,           // mv
-            /\bcp\s+/,           // cp (can create files)
-            /\bmkdir\s+/,        // mkdir
-            /\btouch\s+/,        // touch
-            /\bnpm\s+install/,   // npm install (modifies node_modules)
-            /\bgit\s+commit/,    // git commit
-            /\bgit\s+push/,      // git push
+            /\becho\s+.*>/,
+            /\bcat\s+.*>/,
+            /\brm\s+/,
+            /\bmv\s+/,
+            /\bcp\s+/,
+            /\bmkdir\s+/,
+            /\btouch\s+/,
+            /\bnpm\s+install/,
+            /\bgit\s+commit/,
+            /\bgit\s+push/,
           ]
           
           for (const pattern of dangerousPatterns) {
             if (pattern.test(cmd)) {
-              logEvent("warn", `BLOCKED: ${perms.type} tried dangerous bash command`, { sessionID: input.sessionID, command: cmd })
-              throw new Error(`🚫 BLOCKED: Agent type '${perms.type}' cannot run '${cmd}' - this command modifies files and this agent is READ-ONLY.`)
+              logEvent("warn", `BLOCKED: ${perms.type} tried dangerous bash command`, { sessionID: input.sessionID })
+              throw new Error(`🚫 ${perms.type} is read-only`)
             }
           }
         }