Add task board, plan tracking, and markdown table rendering

- Add TaskItem model and task lifecycle management (create, update,
  resolve temp IDs, prune stale/completed) in SessionState
- Hook into TaskCreate/TaskUpdate/TaskList tool events via
  SessionStore.processTaskTracking for real-time task state sync
- Parse tool_result and tool_response in Python hook script to
  extract resolved task IDs back to Swift
- Add HookEvent fields: toolResult, resolvedTaskId, resolvedTaskSubject
- Add collapsible Task Board UI above chat messages with per-task
  segmented progress bar, status icons, and spinning animation
  for in-progress tasks
- Track ExitPlanMode tool calls to capture plan content and render
  it inline below the tool call in chat
- Add Markdown.Table rendering support with styled header, borders,
  and rounded corners
- Show project name as subtitle in chat header and instance list
- Add PlanDetailView, PlanPreviewView, and PlanWindowController

Author: claude-island

ClaudeIsland/Models/SessionState.swift

@@ -43,6 +43,19 @@ struct SessionState: Equatable, Identifiable, Sendable {
     /// State for Task tools and their nested subagent tools
     var subagentState: SubagentState
 
+    // MARK: - Task Tracking
+
+    /// Tasks created via TaskCreate/TaskUpdate tool calls
+    var tasks: [TaskItem]
+
+    // MARK: - Plan Content
+
+    /// Markdown content of the current plan (from ExitPlanMode)
+    var planContent: String?
+
+    /// Path to the plan file for this session (resolved from ExitPlanMode events)
+    var planFilePath: URL?
+
     // MARK: - Conversation Info (from JSONL parsing)
 
     var conversationInfo: ConversationInfo
@@ -75,6 +88,8 @@ struct SessionState: Equatable, Identifiable, Sendable {
         chatItems: [ChatHistoryItem] = [],
         toolTracker: ToolTracker = ToolTracker(),
         subagentState: SubagentState = SubagentState(),
+        tasks: [TaskItem] = [],
+        planContent: String? = nil,
         conversationInfo: ConversationInfo = ConversationInfo(
             summary: nil, lastMessage: nil, lastMessageRole: nil,
             lastToolName: nil, firstUserMessage: nil, lastUserMessageDate: nil
@@ -93,6 +108,8 @@ struct SessionState: Equatable, Identifiable, Sendable {
         self.chatItems = chatItems
         self.toolTracker = toolTracker
         self.subagentState = subagentState
+        self.tasks = tasks
+        self.planContent = planContent
         self.conversationInfo = conversationInfo
         self.needsClearReconciliation = needsClearReconciliation
         self.lastActivity = lastActivity
@@ -348,3 +365,67 @@ struct TaskContext: Equatable, Sendable {
     var description: String?
     var subagentTools: [SubagentToolCall]
 }
+
+// MARK: - Task Item
+
+/// A task tracked via TaskCreate/TaskUpdate tool calls
+struct TaskItem: Equatable, Identifiable, Sendable {
+    var id: String
+    var subject: String
+    var status: TaskStatus
+
+    enum TaskStatus: String, Sendable {
+        case pending
+        case inProgress = "in_progress"
+        case completed
+        case deleted
+    }
+}
+
+// MARK: - Task Management
+
+extension SessionState {
+    /// Add a new task with a temporary placeholder ID
+    mutating func addTask(subject: String) {
+        let tempId = "_t\(tasks.count)"
+        tasks.append(TaskItem(id: tempId, subject: subject, status: .pending))
+    }
+
+    /// Reset all tasks for a new prompt turn
+    mutating func resetTasks() {
+        tasks.removeAll()
+    }
+
+    /// Resolve a temp task's real ID by matching its subject
+    mutating func resolveTaskId(subject: String, realId: String) {
+        if let idx = tasks.firstIndex(where: { $0.id.hasPrefix("_t") && $0.subject == subject }) {
+            tasks[idx].id = realId
+        }
+    }
+
+    /// Update task status by ID
+    mutating func updateTask(taskId: String, status: TaskItem.TaskStatus) {
+        if let idx = tasks.firstIndex(where: { $0.id == taskId }) {
+            if status == .deleted {
+                tasks.remove(at: idx)
+            } else {
+                tasks[idx].status = status
+            }
+            return
+        }
+        // Fallback: unknown task — create entry
+        if status != .deleted {
+            tasks.append(TaskItem(id: taskId, subject: "Task #\(taskId)", status: status))
+        }
+    }
+
+    /// Remove old pending tasks with temp IDs that were never resolved
+    mutating func pruneStaleTemporaryTasks() {
+        tasks.removeAll { $0.id.hasPrefix("_t") && $0.status == .pending }
+    }
+
+    /// Remove completed tasks to keep the visible list concise
+    mutating func pruneCompletedTasks() {
+        tasks.removeAll { $0.status == .completed }
+    }
+}

ClaudeIsland/Resources/claude-island-state.py

@@ -113,6 +113,28 @@ def main():
         state["status"] = "processing"
         state["tool"] = data.get("tool_name")
         state["tool_input"] = tool_input
+        # Forward tool_result for task ID resolution
+        tool_result = data.get("tool_result")
+        if tool_result:
+            if isinstance(tool_result, str):
+                state["tool_result"] = tool_result
+            elif isinstance(tool_result, dict):
+                # tool_result can be a dict with output/message/content
+                state["tool_result"] = (
+                    tool_result.get("output")
+                    or tool_result.get("message")
+                    or tool_result.get("content")
+                    or ""
+                )
+        # Forward tool_response for structured results (e.g. TaskCreate → {task:{id:...,subject:...}})
+        tool_response = data.get("tool_response")
+        if isinstance(tool_response, dict):
+            # Extract resolved task ID for TaskCreate
+            task = tool_response.get("task")
+            if isinstance(task, dict) and "id" in task:
+                state["resolved_task_id"] = str(task["id"])
+                if "subject" in task:
+                    state["resolved_task_subject"] = task["subject"]
         # Send tool_use_id so Swift can cancel the specific pending permission
         tool_use_id_from_event = data.get("tool_use_id")
         if tool_use_id_from_event:

ClaudeIsland/Services/Hooks/HookSocketServer.swift

@@ -25,6 +25,9 @@ struct HookEvent: Codable, Sendable {
     let toolUseId: String?
     let notificationType: String?
     let message: String?
+    let toolResult: String?
+    let resolvedTaskId: String?
+    let resolvedTaskSubject: String?
 
     enum CodingKeys: String, CodingKey {
         case sessionId = "session_id"
@@ -33,10 +36,13 @@ struct HookEvent: Codable, Sendable {
         case toolUseId = "tool_use_id"
         case notificationType = "notification_type"
         case message
+        case toolResult = "tool_result"
+        case resolvedTaskId = "resolved_task_id"
+        case resolvedTaskSubject = "resolved_task_subject"
     }
 
     /// Create a copy with updated toolUseId
-    init(sessionId: String, cwd: String, event: String, status: String, pid: Int?, tty: String?, tool: String?, toolInput: [String: AnyCodable]?, toolUseId: String?, notificationType: String?, message: String?) {
+    init(sessionId: String, cwd: String, event: String, status: String, pid: Int?, tty: String?, tool: String?, toolInput: [String: AnyCodable]?, toolUseId: String?, notificationType: String?, message: String?, toolResult: String? = nil, resolvedTaskId: String? = nil, resolvedTaskSubject: String? = nil) {
         self.sessionId = sessionId
         self.cwd = cwd
         self.event = event
@@ -48,6 +54,9 @@ struct HookEvent: Codable, Sendable {
         self.toolUseId = toolUseId
         self.notificationType = notificationType
         self.message = message
+        self.toolResult = toolResult
+        self.resolvedTaskId = resolvedTaskId
+        self.resolvedTaskSubject = resolvedTaskSubject
     }
 
     var sessionPhase: SessionPhase {

ClaudeIsland/Services/State/SessionStore.swift

@@ -162,6 +162,19 @@ actor SessionStore {
 
         processToolTracking(event: event, session: &session)
         processSubagentTracking(event: event, session: &session)
+        processTaskTracking(event: event, session: &session)
+
+        // Debug: log tool names to diagnose plan tracking
+        if let tool = event.tool {
+            Self.logger.debug("Hook event: \(event.event, privacy: .public) tool=\(tool, privacy: .public)")
+        }
+        processPlanTracking(event: event, session: &session)
+
+        if event.event == "UserPromptSubmit" {
+            session.resetTasks()
+            session.planContent = nil
+            session.planFilePath = nil
+        }
 
         if event.event == "Stop" {
             session.subagentState = SubagentState()
@@ -318,6 +331,98 @@ actor SessionStore {
         }
     }
 
+    private func processTaskTracking(event: HookEvent, session: inout SessionState) {
+        switch event.event {
+        case "PreToolUse":
+            guard let toolName = event.tool else { return }
+
+            if toolName == "TaskCreate" {
+                if let subject = event.toolInput?["subject"]?.value as? String {
+                    session.addTask(subject: subject)
+                    Self.logger.debug("TaskCreate: added task '\(subject, privacy: .public)'")
+                }
+            } else if toolName == "TaskUpdate" {
+                if let taskId = event.toolInput?["taskId"]?.value as? String {
+                    let existingIds = session.tasks.map { $0.id }.joined(separator: ", ")
+                    Self.logger.debug("TaskUpdate: looking for \(taskId, privacy: .public) in [\(existingIds, privacy: .public)]")
+                    if let statusStr = event.toolInput?["status"]?.value as? String,
+                       let status = TaskItem.TaskStatus(rawValue: statusStr) {
+                        session.updateTask(taskId: taskId, status: status)
+                        Self.logger.debug("TaskUpdate: \(taskId, privacy: .public) → \(statusStr, privacy: .public)")
+                    }
+                    if let subject = event.toolInput?["subject"]?.value as? String,
+                       let idx = session.tasks.firstIndex(where: { $0.id == taskId }) {
+                        session.tasks[idx].subject = subject
+                    }
+                }
+            } else if toolName == "TaskList" {
+                session.pruneStaleTemporaryTasks()
+                session.pruneCompletedTasks()
+            }
+
+        case "PostToolUse":
+            guard event.tool == "TaskCreate" else { return }
+
+            // Primary: use resolved_task_id from tool_response (parsed by Python)
+            if let realId = event.resolvedTaskId {
+                let subject = event.resolvedTaskSubject
+                    ?? event.toolInput?["subject"]?.value as? String
+                if let subject {
+                    session.resolveTaskId(subject: subject, realId: realId)
+                } else if let idx = session.tasks.firstIndex(where: { $0.id.hasPrefix("_t") }) {
+                    session.tasks[idx].id = realId
+                }
+                Self.logger.debug("TaskCreate resolved: id=\(realId, privacy: .public)")
+            }
+            // Fallback: parse from tool_result string "Task #8 created..."
+            else if let result = event.toolResult {
+                if let range = result.range(of: #"Task #(\d+)"#, options: .regularExpression),
+                   let idRange = result[range].range(of: #"\d+"#, options: .regularExpression) {
+                    let realId = String(result[idRange])
+                    if let inputSubject = event.toolInput?["subject"]?.value as? String {
+                        session.resolveTaskId(subject: inputSubject, realId: realId)
+                    } else if let idx = session.tasks.firstIndex(where: { $0.id.hasPrefix("_t") }) {
+                        session.tasks[idx].id = realId
+                    }
+                    Self.logger.debug("TaskCreate resolved (fallback): id=\(realId, privacy: .public)")
+                }
+            }
+
+        default:
+            break
+        }
+    }
+
+    // MARK: - Plan Tracking
+
+    private func processPlanTracking(event: HookEvent, session: inout SessionState) {
+        guard let toolName = event.tool else { return }
+        let isPlanTool = toolName == "ExitPlanMode"
+            || toolName == "exit_plan_mode"
+            || toolName.lowercased().contains("exitplanmode")
+            || toolName.lowercased().contains("planmode")
+
+        guard isPlanTool else { return }
+
+        // Extract plan content and file path directly from toolInput
+        if let input = event.toolInput {
+            if let planContent = input["plan"]?.value as? String, !planContent.isEmpty {
+                session.planContent = planContent
+                Self.logger.debug("Plan loaded from toolInput (\(planContent.count) chars)")
+            }
+            if let pathStr = input["planFilePath"]?.value as? String, !pathStr.isEmpty {
+                session.planFilePath = URL(fileURLWithPath: pathStr)
+            }
+        }
+
+        // Fallback: read from known file path
+        if session.planContent == nil, let path = session.planFilePath,
+           let content = try? String(contentsOf: path, encoding: .utf8) {
+            session.planContent = content
+            Self.logger.debug("Plan loaded from file: \(path.lastPathComponent, privacy: .public)")
+        }
+    }
+
     /// Push the current subagent tool lists from subagentState into the
     /// corresponding ChatHistoryItem.subagentTools so the UI renders them live.
     private func syncSubagentToolsToChatItems(session: inout SessionState) {

ClaudeIsland/UI/Components/MarkdownRenderer.swift

@@ -99,6 +99,8 @@ private struct BlockRenderer: View {
             Divider()
                 .background(baseColor.opacity(0.3))
                 .padding(.vertical, 4)
+        } else if let table = markup as? Markdown.Table {
+            tableView(table)
         } else {
             EmptyView()
         }
@@ -181,6 +183,65 @@ private struct BlockRenderer: View {
             }
         }
     }
+
+    @ViewBuilder
+    private func tableView(_ table: Markdown.Table) -> some View {
+        let headCells = Array(table.head.cells)
+        let bodyRows = Array(table.body.rows)
+
+        VStack(alignment: .leading, spacing: 0) {
+            // Header row
+            HStack(spacing: 0) {
+                ForEach(Array(headCells.enumerated()), id: \.offset) { i, cell in
+                    cellPlainText(cell)
+                        .fontWeight(.semibold)
+                        .foregroundColor(baseColor)
+                        .font(.system(size: fontSize - 1))
+                        .padding(.horizontal, 8)
+                        .padding(.vertical, 5)
+                        .frame(maxWidth: .infinity, alignment: .leading)
+
+                    if i < headCells.count - 1 {
+                        Rectangle().fill(baseColor.opacity(0.15)).frame(width: 0.5)
+                    }
+                }
+            }
+            .background(baseColor.opacity(0.08))
+
+            Rectangle().fill(baseColor.opacity(0.2)).frame(height: 0.5)
+
+            // Body rows
+            ForEach(Array(bodyRows.enumerated()), id: \.offset) { _, row in
+                let cells = Array(row.cells)
+                HStack(spacing: 0) {
+                    ForEach(Array(cells.enumerated()), id: \.offset) { i, cell in
+                        cellPlainText(cell)
+                            .foregroundColor(baseColor.opacity(0.8))
+                            .font(.system(size: fontSize - 1))
+                            .padding(.horizontal, 8)
+                            .padding(.vertical, 4)
+                            .frame(maxWidth: .infinity, alignment: .leading)
+
+                        if i < cells.count - 1 {
+                            Rectangle().fill(baseColor.opacity(0.1)).frame(width: 0.5)
+                        }
+                    }
+                }
+
+                Rectangle().fill(baseColor.opacity(0.08)).frame(height: 0.5)
+            }
+        }
+        .clipShape(RoundedRectangle(cornerRadius: 6))
+        .overlay(
+            RoundedRectangle(cornerRadius: 6)
+                .stroke(baseColor.opacity(0.15), lineWidth: 0.5)
+        )
+    }
+
+    /// Simple plain text extraction from a table cell
+    private func cellPlainText(_ cell: Markdown.Table.Cell) -> SwiftUI.Text {
+        SwiftUI.Text(cell.plainText)
+    }
 }
 
 // MARK: - Inline Renderer