- Added support for live runtime model metadata in team provisioning.
- Implemented functions to extract and manage CLI flag values for team members.
- Updated member specifications to include effective models based on provider defaults.
- Enhanced UI dialogs to check selected providers in parallel, improving responsiveness.
- Added tests for handling model unavailability during team bootstrap and launch processes.
- Introduced CLI_INSTALLER_VERIFY_PROVIDER_MODELS IPC channel for on-demand model verification.
- Implemented handler for verifying provider models in the CliInstallerService.
- Enhanced CLI installation status management with model verification state and availability.
- Updated related components to support model verification feedback in the UI.
- Updated components in the agent-graph renderer to utilize context hooks instead of the store for accessing team data.
- Introduced `useGraphActivityContext` and `useGraphMemberPopoverContext` hooks to streamline data management.
- Refactored `GraphBlockingEdgePopover`, `GraphNodePopover`, and `GraphTaskCard` components for improved performance and readability.
- Enhanced imports in `MemberDetailDialog` for better organization.
- Added stable slot layout support in various components, enhancing the layout and interaction of nodes.
- Updated TypeScript configuration to include new paths for the agent-graph package.
- Refactored layout logic in activity lanes and kanban to accommodate stable slot assignments.
- Enhanced GraphView and GraphControls to support sidebar visibility toggling and owner slot drop handling.
- Introduced new types for layout management in GraphDataPort and related files.
- Updated README to include stable slot layout documentation.
* fix(team): resolve stuck "reconciling" state and skip resume when teammates never spawned
Addresses #54.
When a team launch fails to bootstrap teammates, the team gets stuck showing
"Last launch is still reconciling" indefinitely, and retrying with --resume
reconnects the lead but does not re-spawn the dead teammates. The only
workaround was enabling "Clear context (fresh session)", which loses the
lead's prior conversation context.
Two root causes addressed:
1. createPersistedLaunchSnapshot counted members still in 'starting' state
(agentToolAccepted=false) as 'pending' regardless of launchPhase. When
launchPhase was 'finished' with never-spawned members, the aggregate
state stayed as 'partial_pending' forever, rendered as "still reconciling".
Fix: when launchPhase != 'active', promote such members to
'failed_to_start' so the aggregate becomes 'partial_failure'
("Launch failed partway"), which correctly signals a terminal state.
2. TeamProvisioningService._launchTeamInner always used --resume when a
previous leadSessionId existed, even if the previous launch had no
teammates successfully spawned. The CLI's deterministic reconnect path
restores lead context but does not re-spawn dead teammates, so the team
stays broken across relaunches. Fix: before adding --resume, read the
persisted launch state. If every expected teammate is 'starting' (never
spawned) or 'failed_to_start', skip --resume so the CLI performs a full
fresh bootstrap that spawns all teammates.
Verified manually on Linux: a team stuck in "still reconciling" correctly
transitions to "failed partway" after the first fix, and the next Launch
(without "Clear context") fully bootstraps and brings teammates online.
* fix(team): narrow skip resume to never-spawned teammates
---------
Co-authored-by: 777genius <quantjumppro@gmail.com>
P1: Poller no longer overwrites nextCursor/hasMore — those belong
to the "Load older" flow. Both poller and loadOlder now dedup
messages by messageId or timestamp+from fingerprint.
P1: Cursor is now compound (timestamp|messageId) with stable
tie-breaking sort. Messages sharing the same timestamp at page
boundaries are no longer lost.
P2: getMessagesPage now applies the same enrichment as getTeamData:
leadSessionId propagation and slash-command-result annotation.
P3: Added 3 tests for getMessagesPage covering pagination, cursor
stability with same-timestamp messages, and slash command annotation.
Returning messages: [] broke the slash command annotation test and
any code relying on getTeamData.messages (notifications, dedup).
Keep a small batch (50 newest) in getTeamData for compatibility.
Full message history is available via getMessagesPage() API.
New cursor-based IPC endpoint for the messages timeline panel:
- team:getMessagesPage(teamName, { beforeTimestamp?, limit? })
returns { messages, nextCursor, hasMore }
- Cursor is timestamp-based — stable under live message insertion
- Default page size 50, max 200
getTeamData no longer includes messages in its response, eliminating
the ~1MB messages payload from every team refresh. Messages are now
fetched independently by MessagesPanel.
MessagesPanel changes:
- Fetches initial page on mount via getMessagesPage API
- Auto-refreshes newest page every 5s when team is alive
- "Load older messages" button for pagination
- Falls back to prop messages if API fails (graceful degradation)
The TeamDataWorkerClient logged console.warn when the worker file
was not found, which is expected during tests (no build output).
The test setup treats unexpected warnings as failures.
Downgrade to logger.debug for the "not found" message and remove
the eager warning from resolveWorkerPath().
Critical:
- findLogsForTask: call worker directly instead of wrapping in
wrapTeamHandler, so failures propagate to catch and trigger the
main-thread fallback correctly.
- TeamDataWorkerClient: scope error/exit handlers to the specific
worker instance to prevent a stale worker's exit event from
rejecting pending requests on a replacement worker (race condition).
Major:
- TeamDataWorkerClient: validate teamName and taskId before forwarding
to worker thread (input sanitization).
- team-data-worker: include status, since, and intervals length in
cache key to prevent stale results after filter changes.
- team-data-worker: move logsInFlight.delete() into .finally() so
rejected lookups don't poison the in-flight map permanently.
- MemberLogsTab: reset refreshCountRef and refreshing state in effect
cleanup to prevent the refresh indicator from latching on permanently
when the effect tears down mid-refresh (e.g. on tab switch).
The user inbox (user.json) contains real teammate-to-user messages
generated by Claude Code CLI. Filtering it as a system inbox was
incorrect — it broke message aggregation for user-directed messages.
Only the broadcast inbox (*.json) needs to be excluded since '*'
is not a valid member name and causes a phantom member in the UI.
The broadcast inbox file (inboxes/*.json) was being parsed by
listInboxNames() as a member named "*", which appeared in the UI
as a phantom team member. Since "*" fails the MEMBER_NAME_PATTERN
validation, it could not be removed through the UI.
Filter system inbox names (*, user) from listInboxNames() so they
are not treated as real team members.
Main process — worker thread for team data:
- New team-data-worker thread handles getTeamData and findLogsForTask,
isolating heavy file I/O (scanning 300+ subagent JSONL files) from
Electron's main event loop. getTeamData dropped from ~2000ms on the
main thread to ~110ms via the worker.
- Worker-side dedup and 10s result cache for findLogsForTask prevents
redundant scans when the same task is queried multiple times.
- Discovery cache TTL raised from 5s to 30s — avoids re-scanning the
entire project directory on every call.
- Message cap at 200 in TeamDataService to keep IPC payloads under 1MB
(was sending 2200+ messages / ~3MB, stalling Chromium IPC serialization).
- IPC handlers fall back to main-thread execution if the worker is
unavailable (graceful degradation).
Renderer — useShallow and memoization (55 files):
- Added useShallow to store selectors across 55 renderer files. Batched
individual useStore() calls (e.g. 17 calls in ExtensionStoreView,
10 in ConnectionSection) into single useShallow selectors, cutting
unnecessary re-render checks on every store update.
- MemberLogsTab: three 5-second polling intervals now pause when the
parent tab is hidden (display:none). Previously 5 hidden tabs × 3
intervals = 15 polling timers firing continuously.
- KanbanColumn wrapped in React.memo to skip re-renders when props
haven't changed.
- MemberList: memoized activeMembers/removedMembers/colorMap; replaced
O(n×m) per-member task scan with a pre-computed reviewer map.
- Bounded timer Maps in store initialization to prevent unbounded growth
of debounce/throttle tracking maps during long sessions.
- Eliminated the enrichMemberBranches method from TeamDataService to simplify member branch enrichment logic.
- Updated TeamDetailView to utilize live branch tracking for both lead and member worktrees, enhancing the accuracy of displayed member branches.
- Adjusted various references to ensure membersWithLiveBranches is used consistently across the component.
seedTeammateOperationalPermissionRules already pre-writes MCP tool
rules to settings.local.json before spawning the CLI. But standard
file tools (Write, Edit, NotebookEdit) were missing.
FACT: Teammates requesting Write get setMode: acceptEdits suggestion
but we can't change subprocess session mode. Pre-seeding these tools
as allow rules prevents the permission prompt entirely.
Belt-and-suspenders approach:
1. Settings file: handles all FUTURE calls (teammate finds rule on retry)
2. control_response via stdin: may unblock CURRENT waiting prompt
(now includes updatedInput: {} which was the previous ZodError fix)
Without #2, approved teammates stay stuck until team restart because
the CLI doesn't hot-reload settings.local.json for pending prompts.
FACT: Write/Edit permission_requests have permission_suggestions with
type "setMode" (not "addRules"): { type: "setMode", mode: "acceptEdits" }
Our code only handled "addRules", so Write/Edit approvals were no-ops.
Translate setMode suggestions to settings rules:
- acceptEdits → add Edit, Write, NotebookEdit to allow list
- bypassPermissions → add all common tools to allow list
- Replaced inline drawing logic for task comments with a new `drawCommentBubble` function to enhance readability and maintainability.
- The new function encapsulates the drawing of a speech-bubble icon, including the rounded rectangle body, tail, and inner dots to suggest text.
- Added mcpToolCatalog to the agent-teams-controller, exporting new types and constants for MCP tool groups and names.
- Updated tools registration to utilize AGENT_TEAMS_MCP_TOOL_GROUPS for streamlined tool management.
- Enhanced tests to validate the new operational permissions and ensure correct tool registration behavior.
When user approves any mcp__agent-teams__* tool, also add all other
agent-teams tools to settings.local.json preemptively. This prevents
teammates from getting stuck on subsequent tool calls (task_get,
task_start, task_complete, etc.) since each generates a separate
permission_request and the teammate blocks until resolved.
FACT: Settings file approach only prevents FUTURE blocks, not current
ones. Pre-adding all tools on first approval covers the common case.
- Added checks to ensure that only newer versions are installed during the update process.
- Updated the notification logic to suppress alerts for non-newer updates.
- Introduced a new method to compare version numbers, improving version management in the UpdaterService.
- Enhanced the release workflow by removing unnecessary file uploads and adding canonical updater metadata publishing for better asset management.
Claude Code CLI Zod schema requires updatedInput to be a record
when behavior is 'allow'. Without it, MCP tool approvals fail with
'Tool permission request failed: ZodError: expected record, received
undefined'.
Add empty updatedInput: {} to all allow responses (autoAllow,
timeout-allow, and manual allow).
Inbox files persist across team runs. Permission_request messages from
a previous run (e.g. when team was launched without auto-approve) were
being reprocessed on the next launch, showing false ToolApprovalSheet
popups even when the new run has bypassPermissions enabled.
Filter by timestamp: skip permission_request messages older than
run.startedAt.
Tool approval settings (autoAllowAll, autoAllowFileEdits, etc.) are
now stored per-team instead of globally. Clicking 'Allow all' in one
team no longer affects other teams.
- localStorage key: 'team:toolApprovalSettings:{teamName}'
- Settings loaded on team select, initialized on create/launch
- skipPermissions=false -> defaults (autoAllowAll:false)
- skipPermissions=true -> autoAllowAll:true for that team
- Main process: Map<teamName, settings> instead of single instance
- IPC: teamName parameter added to updateToolApprovalSettings
Split setTracking(enabled) into separate enableTracking/disableTracking
public methods per sonarjs/no-selector-parameter rule. Update all callers
and test mocks accordingly.
- Added logic to remove generated MCP config files when team creation or launch fails due to spawn errors.
- Updated tests to verify that MCP config files are correctly removed in failure scenarios, ensuring no leftover configurations persist.
- Enhanced error handling in the TeamProvisioningService to maintain clean state during provisioning operations.
MCP config files were stored in os.tmpdir() with no cleanup, and
the MCP server ran from the AppImage FUSE mount path which could
be inaccessible to Claude CLI subprocesses on Linux (fixes#31).
Changes:
- Store MCP configs in app.getPath('userData')/mcp-configs/ with
pid+timestamp filenames for safe multi-instance operation
- Copy MCP server to userData/mcp-server/<version>/ via atomic
temp-dir + rename (eliminates FUSE mount dependency)
- Add per-run cleanup in cleanupRun(), startup stale GC (7d TTL),
and shutdown own-pid GC
- Add --mcp-config recovery in respawnAfterAuthFailure()
- Add setAppDataBasePath(null) reset for test isolation
- Introduced 'task_comment_notification' message kind to enhance message handling in the team services.
- Updated TeamDataService, TeamInboxReader, and TeamSentMessagesStore to accommodate the new message kind.
- Modified filtering logic to exclude task comment notifications from the displayed messages.
- Added tests to ensure correct handling and filtering of task comment notifications.
- Added visual differentiation for 'task_comment' particles, adjusting size and glow effects.
- Updated drawing functions to handle new particle kind, ensuring proper rendering in the graph.
- Introduced a merge function for particles to prevent duplicates during state updates.
- Enhanced color constants for better visual representation of different particle types.
Restored markInboxMessagesRead for permission_request messages in the
early scan. Without this, processed permission_request messages stayed
read=false forever, potentially showing stale unread indicators in UI.
Root cause: handleTeammatePermissionRequest was called from 3 paths
(early inbox scan, Category 4 relay scan, stdout/native) but only
the early scan checked processedPermissionRequestIds, causing
duplicate ToolApprovalRequests and extra permission_responses.
Fix:
- Move processedPermissionRequestIds check INTO handleTeammatePermissionRequest
so ALL callers are protected by the same dedup gate
- Remove duplicate Category 4 scan that re-processed inbox messages
(early scan already covers all messages including read=true)
- Category 4 now only builds a filter Set to exclude permission_request
from relay to lead
Context window fix:
- Derive initial contextWindow from model selection (haiku=200K, else=1M)
- Use limitContext flag from request
- Updated to exact value from modelUsage on result.success
- Formula: input_tokens + cache_creation + cache_read (all three needed)
TokenUsageDisplay:
- New contextWindowSize prop → shows "X% of context" (not "X% of input")
Graph improvements:
- Pending approval: pulsing amber ring on member nodes
- Working spinner: spinning arc when member has active task
- Current task indicator in popover (Loader2 + "working on" + task name)
- GraphNode: added currentTaskId, currentTaskSubject, pendingApproval, activeTool fields
- Adapter: passes pendingApprovalAgents + currentTaskId from store
- Option keys now include question index prefix ("qi:label") to prevent
cross-question collisions when multiple questions share option labels
- Single-select clears only options from the same question, not all
- answersMessage built as per-question JSON map instead of flat join
- Backend parses JSON answers and maps to correct questions
- Fallback label "Option N" for options with undefined label
- Enter key now respects isAskQuestion selection requirement
- Selected option labels sent as message to respondToToolApproval
- control_response includes updatedInput with answers for AskUserQuestion
- useCallback/useEffect deps updated for selectedOptions and hasSelection
relayLeadInboxMessages only processes unread messages after
provisioningComplete, but CLI marks permission_request messages as
read after native delivery -- before our relay runs.
Move permission_request inbox scan BEFORE provisioningComplete check.
Scan ALL messages (including read=true), track processed IDs via
processedPermissionRequestIds Set on ProvisioningRun to prevent
re-emitting. Also look up both alive and provisioning runs so the
scan works during team bootstrap.
- Parse raw user text for permission_request in handleStreamJsonMessage
(covers case where permission_request arrives without <teammate-message> wrapper)
- Add [PERM-TRACE] logger.warn diagnostics to trace the exact flow:
where permission_request is detected, whether it reaches handleTeammatePermissionRequest,
and whether relay or stdout interception triggers
- These logs will help diagnose why ToolApprovalSheet may not appear
relayLeadInboxMessages only runs after provisioningComplete, but
teammate permission_request messages arrive during bootstrap (before
provisioning finishes). Claude Code delivers them natively via stdout
type:"user" messages, bypassing the relay entirely.
Add permission_request interception in handleNativeTeammateUserMessage
which processes stdout user messages at all times, including during
provisioning. This ensures ToolApprovalSheet appears immediately when
teammates need tool permission.
When Claude Code runtime natively delivers permission_request to the
lead via stdout, the message was excluded from interception by the
nativeMatchedMessageIds filter. This caused the ToolApprovalSheet to
not appear for teammate requests.
Remove nativeMatchedMessageIds check from the permission_request
filter so interception works even for natively delivered messages.
When auto-approve is disabled, teammate tool requests arrived as
permission_request JSON via SendMessage and rendered as "Raw JSON"
with no way to approve/deny (#29).
- Intercept permission_request in lead inbox relay, convert to
ToolApprovalRequest and show in existing ToolApprovalSheet
- Respond via teammate inbox (permission_response) + control_response
via stdin as fallback
- Show teammate name in approval header (e.g. "bob — Bash")
- Compact noise label in Messages panel for permission_request/response
- Proper file locking, race condition protection, idempotency checks
- Added support for tracking task change presence with new IPC channels: TEAM_GET_TASK_CHANGE_PRESENCE and TEAM_SET_CHANGE_PRESENCE_TRACKING.
- Introduced JsonTaskChangePresenceRepository and TeamLogSourceTracker to manage task change presence data.
- Enhanced ChangeExtractorService to utilize task change presence services for improved task change detection.
- Updated TeamDataService to integrate task change presence tracking and resolve task change presence states.
- Modified UI components to reflect task change presence status in Kanban and task detail views.
This feature aims to provide real-time insights into task changes, enhancing user experience and task management capabilities.
HEAD-request the expected installer URL (DMG/EXE/AppImage) before
notifying the user about a new version. If CI hasn't finished
uploading the artifact for the current OS yet, the notification is
suppressed and retried on the next periodic check.
Extract sendUserTaskStartNotification as reusable private method.
When a task is created via UI directly in "In Progress" column
(startImmediately=true), the controller's maybeNotifyAssignedOwner
skips the lead. Now createTask sends the notification to the lead
with full description, prompt, and task_get instructions.
- Added a new IPC handler for starting tasks triggered by users, ensuring that the task owner is always notified.
- Introduced `startTaskByUser` method in `TeamDataService` to handle task initiation and notifications.
- Updated relevant components and API interfaces to support the new functionality, including changes in the UI to call `startTaskByUser` instead of the previous `startTask`.
- Documented agent block usage for internal instructions in CLAUDE.md.
This enhancement improves user interaction with task management by providing a clear mechanism for user-initiated task starts.
Manually ported from upstream:
- ef2e0868: deduplicate streaming JSONL entries by requestId
- 4f21f267: mark stale ongoing sessions as dead after 5min inactivity
- Changed references in messages to use the **Agent** tool instead of the Task tool for spawning teammates.
- Added warnings for missing team_name to ensure agents are persistent rather than ephemeral.
- Updated documentation within the code to reflect the new requirements for spawning teammates.
- Use buildEnrichedEnv() in PtyTerminalService so login terminal gets
full PATH (Homebrew, nvm, etc.) and USER for Keychain lookup
- Add cliInstaller:invalidateStatus IPC to clear cached auth status
after successful login, preventing stale "not logged in" responses
- Show "Verifying authentication..." spinner instead of flashing
the "Not logged in" banner between modal close and status refresh
Ref #27
On macOS, the Claude CLI uses a Keychain namespace derived from the
presence of CLAUDE_CONFIG_DIR env var. Setting it to the default
~/.claude creates a different Keychain key than when the var is absent,
causing "not logged in" errors even after successful `claude auth login`.
Only set CLAUDE_CONFIG_DIR when the user has configured a custom path
that differs from the auto-detected default.
Fixes#27
fs.rm() without { recursive: true } throws ERR_FS_EISDIR on directories,
unlike the deprecated fs.rmdir() which handled empty dirs. Also fix
broken roadmap bullet in README.
- Fix incorrect error message when attaching files to team lead while team is offline
- Kanban columns: color only on headers, body with 30% alpha tint per user preference
- Worktree projects now correctly detected on Dashboard via path-based detection
- Filter raw protocol messages (idle_notification, teammate-message) from lead thoughts
- Consistent text styles in Attachments section (From original message / From comments)
- Secondary sort for teams by lastActivity timestamp with alphabetical fallback
- Remove colored background from team cards, keep only left border
- Dynamic member color in Add Members dialog based on next available palette color
- Stylized @-mentions in task comments with colored MemberBadge
- Refactor CLI env resolution to shared utility
- Rearranged roadmap items in README.md for better organization, moving planning mode and visual workflow editor to the top.
- Updated the flag icon for English in LanguageSwitcher.vue from the US to the GB flag.
- Enhanced user environment setup in CliInstallerService.ts by adding user information retrieval.
- Improved timestamp handling in MemberLogsTab.tsx to better reflect recent activity.
- Adjusted button class names in ProvisioningProgressBlock.tsx for consistency.
- Introduced baseURL configuration to dynamically set asset paths in the landing components.
- Updated AppLogo and HeroSection components to use baseURL for logo image sources.
- Refactored ScreenshotsSection to utilize a publicPath function for consistent image path handling.
- Improved LanguageSwitcher to synchronize the i18n locale with the store on mount.
- Enhanced TaskCommentInput to handle file uploads more robustly, including validation for empty files and improved error handling.
- Adjusted MessageComposer to conditionally support attachments based on team status.
- Upgraded TypeScript target and library to ES2023 for improved language features.
- Enhanced TeamProvisioningService to better handle plain text attachments with UTF-8 validation.
- Improved TaskCommentInput to differentiate between image and non-image file previews, including a new FileIcon for non-image files.
- Refactored attachment handling in useAttachments and useComposerDraft hooks to simplify file processing.
- Added validation for empty files in attachmentUtils to improve user feedback on unsupported uploads.
- Added support for additional attachment types: PDF and plain text.
- Updated the TeamProvisioningService to handle new attachment types with appropriate content blocks.
- Enhanced AttachmentDisplay and AttachmentPreview components to differentiate between image and non-image files.
- Modified DropZoneOverlay and SendMessageDialog to reflect changes in file handling and messaging.
- Improved user experience by allowing file previews for non-image attachments and updating error messages accordingly.
- Refactored attachment validation logic to categorize unsupported files and handle them gracefully.
- Added logic to merge "lead" alias into "team-lead" to prevent phantom member entries in the inbox.
- Updated provisioning instructions to emphasize the importance of using the exact name for the team lead in messages, avoiding abbreviations.
- Modified default role for 'tom' from 'reviewer' to 'researcher' with updated workflow description.
- Improved UI in MemberDraftRow to indicate workflow status with a visual cue when expanded.
- Changed image format for agent comments screenshot in README.
- Improved table of contents in README for better navigation.
- Refactored imports in IPC config and discovery services for consistency.
- Added shimmer effect for waiting members in CSS.
- Enhanced dashboard view to display active teams with online indicators.
- Updated team provisioning components to support message severity.
- Improved task detail dialog layout for related tasks and dependencies.
- Adjusted team model selector default value and refined member status handling.
- Fixed minor styling issues in messages panel and tab bar.
These changes aim to improve user experience and maintainability across the application.
Teammates are independent Claude Code processes that read their own inbox
files via fs.watch. Relaying DMs through the lead caused three bugs:
lead responding instead of the teammate, duplicate messages from relay
loops, and teammates not responding to user due to conflicting prompts.
- Disable relayMemberInboxMessages for teammate DMs (teams.ts, index.ts)
- Add SendMessage(to="user") filter in captureSendMessages as safety net
- Generate deterministic messageId for inbox entries lacking one (sha256)
- Wrap notification instructions in agent block, italic task subject
- Style system comments in task view with blue background, hide avatar
- Update CLAUDE.md, research docs, and code comments with architecture
- Integrate @sentry/electron and @sentry/react for crash reporting
- Add Sentry Vite plugin for source maps
- Add error tracking to main process, renderer, and IPC layer
- Exclude source maps from packaged builds
- Update README with new screenshots
- Add Sentry opt-out toggle in settings
- Update release workflow with Sentry config
Add explicit constraint in lead prompt forbidding SendMessage with
recipient "*". The broadcast address is not supported by the runtime
and creates a phantom team member named "*" in the UI.
- Add green "Update app" / "Restart to update" button in header (TabBarActions)
- Enhance UpdateDialog: larger, dynamic buttons, scrollable release notes,
version badge, "View on GitHub" link
- Add DashboardUpdateBanner: compact dismissible banner keyed by version
- Add periodic hourly update checks in UpdaterService with unref() timer
- Add dismissed version tracking in updateSlice (localStorage persistence)
- Add state transition guards in store listener: prevent periodic re-checks
from resetting downloading/downloaded status back to available/checking
- Guard error events from overriding downloaded state (transient check failures)
When a team was permanently deleted and a new team created with the
same name, the backup service still treated it as deleted. The old
registry entry blocked periodic backups, FileWatcher-triggered backups,
shutdown backups, and auto-restore on startup.
- discoverActiveTeams: re-activate deleted entries when valid config exists
- doBackupTeam: reset stale deleted manifest, always ensure identity marker
- doBackupTeam guard: allow resurrected teams through with config check
- doBackupTeamSync: reset deleted manifest to prevent status writeback
- reconcileResurrectedTeams: detect post-deletion backup data on init
- reconcileResurrectedTeamsSync: sync reconciliation before shutdown backup
Use ClaudeBinaryResolver instead of null binary path in extension services
(McpHealthDiagnosticsService, PluginInstallService, McpInstallService).
Packaged Electron on macOS has minimal PATH — bare `claude` lookup fails
with ENOENT. Now all CLI calls resolve the binary via ClaudeBinaryResolver
which checks PATH, NVM, standard install dirs and login shell env.
- Add buildEnrichedEnv() helper for child process env (PATH, HOME, USERPROFILE)
- Add stale cache re-verification with 30s TTL in ClaudeBinaryResolver
- Guard execCli() against null binaryPath with explicit error
- Replace projectPath.startsWith('/') with path.isAbsolute() for Windows
- Extract CLI_NOT_FOUND_MARKER/MESSAGE constants for consistent error detection
- Show amber info banner instead of red error when CLI not installed
- Revised the TeamProvisioningService to change event handling from 'Task' to 'Agent' for improved accuracy.
- Enhanced the StepProgressBar component to include error indicators and animations for better user feedback during provisioning.
- Updated the TeamProvisioningBanner to track and display the last active step in case of errors.
- Improved CSS styles for step indicators, adding new animations and error states.
- Refined the sidebar task item styling based on light/dark themes for better visual consistency.
- Adjusted the README to reflect changes in installation instructions and feature comparisons.
- Updated the TeamProvisioningService to advance the provisioning state to "assembling" when the first member spawn is detected.
- Improved the clarity of team setup progress tracking by refining the conditions for state transitions.
- Adjusted the README to include a new section on installation and a detailed comparison of features against other multi-agent orchestration tools.
- Updated provisioning states to include 'configuring', 'assembling', and 'finalizing' for better tracking of team setup progress.
- Refactored the provisioning progress block to utilize a new display step system, improving clarity in the UI.
- Adjusted the README to include a comprehensive table of contents and updated comparison metrics for multi-agent orchestration tools.
- Enhanced team management UI to reflect new provisioning states and improve user experience during team setup.
- Replaced instances of isLeadAgentType with isLeadMember for improved clarity in team member role checks.
- Updated README to include a new built-in review workflow feature for agent task reviews.
- Enhanced team detail and list views to accurately reflect current team members and their roles.
- Improved CSS for step progress indicators, adding new styles for a circular stepper.
- Refactored provisioning progress block to utilize a new StepProgressBar component for better visual representation of steps.
- Changed task assignment message to use italic formatting for task subject for better emphasis.
- Updated the task instruction message to utilize a wrapping function for improved readability.
- Enhanced splash screen background with an animated gradient for a more dynamic visual experience.
- Improved team detail view messaging to clarify provisioning status.
- Adjusted member list sorting logic to utilize a new lead member detection function.
Electron's 'action' event fires on both macOS and Windows per docs.
Removed isMac guard — now Allow/Deny buttons appear on Windows too.
Linux excluded (libnotify doesn't fire the 'action' event).
- Click handler reads this.mainWindowRef instead of captured closure ref,
so window recreation is handled correctly
- reEvaluatePendingApprovals now calls dismissApprovalNotification when
auto-allowing via settings change (was missing — stale notification stayed)
- Add teamProvisioningService.setMainWindow(null) in window close handler
- Add teamProvisioningService.setMainWindow(mainWindow) in window recreate
Without this, notification click focused destroyed window instead of new one
- Remove unused dismissAllApprovalNotifications (cleanupRun uses per-requestId dismiss)
- Track notifications by requestId (Map instead of Set) so they can
be dismissed individually when the approval is resolved
- Dismiss OS notification in respondToToolApproval (via UI or action)
- Dismiss OS notification on timeout auto-resolve
- Dismiss all OS notifications on cleanupRun (team stop/exit)
- Respect snoozedUntil — skip notification if user snoozed all
When a tool needs approval and the app is not focused, show a native
OS notification with clear description (tool name + file/command).
On macOS: notification includes Allow and Deny action buttons that
respond directly without switching to the app.
On all platforms: clicking the notification focuses the app window.
New setting: notifyOnToolApproval (default: true) in notification
settings with ShieldQuestion icon toggle.
- Added functionality to read draft team summaries from team.meta.json when config.json is missing.
- Introduced methods to save team-level metadata to team.meta.json during team creation.
- Updated UI components to handle draft teams, including launch and delete options.
- Enhanced error handling for draft teams in various components.
syntheticRequest for team launch was missing color and displayName
fields — they only existed in TeamCreateRequest (create flow).
Now reads color and name from config.json when building
syntheticRequest, so ToolApprovalRequest always has team color.
- Add diff preview for Write/Edit tools: reads current file via new IPC
(TEAM_TOOL_APPROVAL_READ_FILE), shows unified diff using existing DiffViewer
- Fix Allow button doing nothing: re-throw errors from store instead of
silently swallowing, show error message in UI, add 10s safety timeout
- Fix "No active process" during provisioning: use getTrackedRunId() to
find process in both provisioning and alive maps
- Add 5s stdin.write timeout to prevent hanging when process dies
- Add syntax highlighting for tool input preview (JSON, bash, etc.)
- Add team color/name badge from ToolApprovalRequest (works during provisioning)
- Conditionally show team badge only when user is on a different team page
- Format elapsed time as Xm Ys when over 60 seconds
- Replace native <select> with Radix UI Select in settings panel
- Enhanced the HttpServer class to prevent multiple concurrent calls to the start() method by introducing a startingPromise that ensures subsequent calls await the same promise.
- Added a private doStart method to encapsulate the server startup logic.
- Updated documentation to reflect the new behavior of the start method.
- Adjusted the ActivityTimeline component to improve padding in the "No messages" state for better visual alignment.
- Updated the TeamProvisioningService to pre-create team configuration and member metadata before spawning the CLI, ensuring persistence even in case of failures.
- Modified return messages to reflect the new provisioning flow, indicating that the team configuration has been pre-created.
- Adjusted the steps in the provisioning process to streamline the creation and provisioning of teams, improving overall user experience.
Teammates must now post full results as a task comment (via task_add_comment)
before calling task_complete, then send a brief summary to the lead with
a pointer to the comment (first 8 chars of comment.id). This ensures results
are visible on the task board, not buried in ephemeral direct messages.
- Add task_get_comment MCP tool for fetching a single comment by id/prefix
- Add "save comment.id → use it in SendMessage" flow with concrete examples
- Update all teammate prompts: spawn, reconnect, assignment, briefing, task protocol
- Add task_get_comment to lead's MCP tools list with usage hint
- Optimize resolveTaskRef: fast-path for UUID (skip full dir scan)
- Updated task management guidelines to emphasize the importance of posting task comments before marking tasks as complete, ensuring visibility of results on the task board.
- Introduced a new notification system for team leads after task completion, summarizing key findings and linking to detailed comments.
- Improved UI components, including a new CLI checking spinner with a delayed hint and enhanced task filters to support unread/read task states.
- Refactored sidebar task item styles to visually indicate unread tasks and adjusted task sorting options to include 'unread' as a criterion.
- Enhanced settings tabs with tooltips for better user guidance and improved layout for advanced settings options.
In packaged Electron apps process.cwd() does not point to the app
directory so the mcp-server bundle was never found. Additionally the
mcp-server dist was not included in the package at all.
Changes:
- Bundle mcp-server into a single self-contained ESM file (tsup
noExternal + createRequire banner for CJS compat)
- Ship mcp-server/dist/index.js and package.json via extraResources
- Resolve entry via process.resourcesPath when app.isPackaged is true
- Build controller + mcp-server in prebuild so dist exists before
electron-builder runs
- Add mcp-server/dist/index.js to CI verify steps on all platforms
- Improve error message to list checked paths for easier debugging
- Added a pre-warming mechanism for the interactive shell environment at app startup to improve PATH resolution for CLI services.
- Introduced getCachedShellEnv function to retrieve the cached shell environment synchronously, aiding in non-blocking PATH enrichment.
- Updated buildChildEnv function to incorporate enriched PATH from the cached shell environment, ensuring reliable access to user-installed binaries.
- Refactored CLI process environment setup to utilize the binary path for more accurate environment configuration.
- Removed unnecessary eslint disable comments related to intentional mutations for clarity.
- Updated import statements for consistency and organization.
- Refactored regex patterns and utility functions in various components to enhance performance and maintainability.
- Improved error handling and notifications for API errors in the teams IPC module.
- Streamlined the handling of DOM mutations in the ChatHistory and other components for better readability.
- Enhanced type definitions and added utility functions to improve code structure and type safety.
- Updated TeamDataService to include lightweight comment metadata in the GlobalTask payload, addressing issues with task comment notifications in the renderer.
- Enhanced TeamProvisioningService with a stall watchdog to monitor CLI process responsiveness and emit warnings for extended periods of inactivity.
- Modified CreateTeamDialog and LaunchTeamDialog to ensure default values for selected model and effort are set correctly, improving user experience during team creation and launch.
- Added MEMBER_DELEGATE_DESCRIPTION constant to centralize the delegate instructions for action mode protocols, improving code maintainability.
- Updated buildActionModeProtocolText to utilize the new constant, enhancing clarity and reducing duplication.
- Enhanced messageStore and TeamProvisioningService to support filePath handling in attachments, improving metadata management.
- Updated type definitions to reflect the addition of MEMBER_DELEGATE_DESCRIPTION in the protocols interface.
- Introduced `buildActionModeProtocolText` function to generate context-free action mode protocol text, enhancing clarity for both leads and members.
- Updated the `protocols` interface to include the new function, promoting code reuse across different components.
- Refactored existing logic in `actionModeInstructions.ts` and `TeamProvisioningService.ts` to utilize the new protocol text builder, improving maintainability and consistency.
- Enhanced type definitions to reflect the addition of the new protocol functionality.
- Introduced a new function `buildProcessProtocolText` to generate context-free protocol text for background process registration.
- Updated the `protocols` interface to include the new function, promoting code reuse across member and lead prompts.
- Integrated the new protocol text into the team provisioning service for improved operational instructions.
- Enhanced type definitions to reflect the addition of the new protocol functionality.
- Introduced a new notification setting for when a team finishes launching, enhancing user awareness of team readiness.
- Updated the configuration interface and default settings to include the new notification option.
- Implemented logic to trigger the "team launched" notification within the team provisioning service.
- Enhanced validation to ensure the new setting accepts boolean values.
- Updated relevant UI components to allow users to toggle the new notification setting.
- Added instructions for retrieving task details and listing all tasks to the team operations documentation.
- Improved clarity on task management processes within the team provisioning service.
- Modified review request instructions to include an optional note parameter for better context during reviews.
- Added clarification flag instruction to team operations documentation, improving guidance for task management.
- Added filePath to attachment metadata in various components to support file access.
- Updated saveTaskAttachmentFile and related functions to include file paths for stored attachments.
- Enhanced documentation and comments to clarify the importance of using MCP tools for task review operations.
- Improved UI components to display file paths where applicable, ensuring better user experience with attachments.
- Added scanProjectWithTimeout method to ProjectScanner to prevent long scans from blocking the entire batch.
- Introduced cleanup logic in metadata extraction functions to ensure proper resource management during timeouts.
- Updated logging to provide insights on scan durations and session statistics for better performance monitoring.
- Enhanced repository group fetching logic in DashboardView and DateGroupedSessions components to handle loading and error states more effectively.
- Added startReview function to initiate the review process for tasks, allowing transition to the review column without requiring completed status.
- Updated getCurrentReviewState and getEffectiveReviewState functions to include 'review_started' event type for accurate review state tracking.
- Enhanced task history management by introducing a new TaskReviewStartedEvent type.
- Updated documentation and user instructions to reflect the new review process, emphasizing the importance of calling review_start before review actions.
- Improved test coverage for the new startReview functionality and its integration with existing review processes.
- Updated reviewTools to utilize slimTask for lightweight task representations, improving response efficiency.
- Enhanced taskTools to apply slimTaskForList for task listing, reducing data payloads.
- Introduced new slimTask and slimTaskForList functions in format utility for better task data management.
- Improved test coverage for slim task operations, ensuring accurate behavior in task handling and review processes.
- Updated taskTools to utilize slimTask for lightweight task summaries, reducing data bloat in responses.
- Introduced taskWriteResult function to handle task write operations more efficiently by stripping unnecessary fields.
- Enhanced jsonTextContent usage across task operations for consistent data formatting.
- Removed legacy member briefing bootstrap checks from TeamProvisioningService and related tests to simplify member spawn logic.
- Improved test coverage for task handling and member provisioning processes.
- Updated TeamProvisioningService to include subagent type in spawn messages for clarity.
- Improved member registration checks to account for suffixed names, enhancing error handling.
- Refactored SubagentRecentMessagesPreview to strip agent-only blocks from messages, improving display clarity.
- Adjusted tests to reflect changes in message formatting and member provisioning logic.
- Simplified member spawn event handling by removing redundant checks for missing parameters.
- Introduced a new audit function to verify registered members against expected members post-provisioning, flagging any discrepancies.
- Updated logging to provide clearer warnings for unregistered members after provisioning.
- Enhanced test cases to ensure accurate behavior of spawn handling and auditing processes.
- Introduced stable messageId generation for reliable task creation and message tracking.
- Updated TeamAttachmentStore with a TODO for attachment cleanup on failed sends.
- Enhanced task notifications and UI components to improve user experience, including custom role rendering in RoleSelect and improved task detail displays.
- Refactored task change handling logic to support better visibility of changes across task states.
- Added support for displaying source message attachments in TaskDetailDialog.
- Improved overall code structure and documentation for better maintainability.
- Detect review state transitions (kanbanColumn → review) in status change notifications
- Add "All tasks completed" notification when every task in a team reaches completed/deleted
- Add "Cross-team message" notification with separate toggle (source: cross_team in inbox)
- All three enabled by default with UI toggles in settings
- Updated `lookupMessage` function to enforce exact messageId matching, rejecting ambiguous cases.
- Improved documentation for `task_create_from_message` to clarify its requirements and usage.
- Enhanced `buildAssignmentMessage` and related functions to include messageId in task notifications for better provenance tracking.
- Added tests to validate the integration of messageId in task creation and relay processes, ensuring accurate message handling.
- Introduced a new `lookupMessage` function to retrieve messages by their exact messageId from both sent messages and inbox files.
- Enhanced error handling for ambiguous messageId scenarios and missing messageId cases.
- Updated the `createTask` function to include `sourceMessageId` and `sourceMessage` fields, capturing the original message details during task creation.
- Added comprehensive tests for the `lookupMessage` functionality, ensuring accurate retrieval and validation of messages from different sources.
- Enhanced regex patterns in TeamMemberLogsFinder to allow for escaped sequences and increased character limits for text and content previews.
- Updated the MemberLogsTab component to prioritize recent previews over fallback mechanisms, ensuring more relevant message displays for lead users.
- Adjusted the length limit for returned previews to 1500 characters for better context in log summaries.
- Added support for tracking and displaying recent thinking previews alongside output previews in TeamMemberLogsFinder.
- Updated the return structure of log summaries to include last thinking previews and recent previews for better context.
- Enhanced the MemberLogsTab component to utilize recent previews for lead users, improving the clarity and relevance of displayed messages.
- Implemented filtering logic for task-scoped recent previews, ensuring only relevant messages are shown based on task intervals.
- Removed `remark-stringify` from the project to avoid ESM→CJS interop issues in Electron's main process.
- Updated the text formatting pipeline to use a custom plain-text compiler instead of `remark-stringify`.
- Enhanced task ID matching logic in `TeamMemberLogsFinder` to accommodate both full UUIDs and their short display forms, improving flexibility in task identification.
- Added comments to clarify the changes in task ID handling and regex construction.
- Added `remark-stringify` to the project for converting markdown to plain text.
- Updated the text formatting pipeline to include `remark-stringify` for improved markdown handling.
- Commented out performance logging in `TeamMemberLogsFinder` to reduce console output during execution.
- Enhanced the `getUnreadCount` and `getLegacyCutoff` functions in `commentReadStorage` to clarify legacy comment handling logic.
- Added a `suppressTaskComment` flag to the `approveReview` function, allowing users to approve reviews without adding a comment to the task.
- Updated the `notifyNewInboxMessages` function to include additional debug logging for better tracking of inbox notifications.
- Adjusted notification settings in `ConfigManager` to enable notifications for lead inbox and change the status change behavior.
- Enhanced the `NotificationManager` to improve error handling and logging during notification display.
- Refactored `TeamDataService` to utilize the new `suppressTaskComment` feature during review approvals.
- Updated tests to validate the new approval process and notification behaviors.
- Introduced `relayOfMessageId` to various message handling components, allowing for better tracking of relayed messages.
- Updated `buildMessage`, `TeamInboxReader`, `TeamInboxWriter`, and related services to accommodate the new relay ID.
- Enhanced filtering logic in `filterTeamMessages` to hide relay copies when the original message is visible, improving message clarity.
- Added tests to validate the functionality of relay message handling and ensure proper integration across services.
- Introduced a new function `quoteMarkdown` to format task comments with markdown quotes for better readability.
- Updated the `buildCommentNotificationMessage` to utilize `quoteMarkdown`, ensuring comments are displayed correctly.
- Refactored member role detection across multiple services to use `isLeadMember` for consistency and clarity in identifying team leads.
- Enhanced various components to improve handling of team member roles, ensuring accurate representation in UI and logic.
- Adjusted tests to reflect changes in comment formatting and member role checks, improving overall reliability.
- Auto-backup team files (config, tasks, inboxes, attachments, etc.)
to app's own storage (Electron userData) every 3 minutes
- Sync backup on app shutdown (after SIGKILL, before cleanup)
- Auto-restore missing/corrupted teams on startup with identity guard
- Move attachments to app-owned storage (outside ~/.claude/)
- Add stopAllTeams() with SIGKILL for reliable shutdown
- Clean up app data when permanently deleting teams
- Generation-based shutdown isolation prevents async/sync races
- Added debug logging for test notification handling in the NotificationManager, improving traceability during notification operations.
- Implemented unescaping of literal newline sequences in task descriptions and comments across various components, ensuring proper formatting.
- Updated task comment handling logic to clarify awaiting replies from task responders, enhancing user awareness of task interactions.
- Refined UI components to improve user experience in settings and task management, including adjustments to the NotificationsSection and TeamDetailView.
- Introduced a new IPC call for sending test notifications, allowing users to verify notification delivery.
- Updated app identifiers in package.json and notarization script to reflect the new application name.
- Enhanced notification handling in the NotificationManager to prevent garbage collection of active notifications.
- Updated UI components to include a test notification button in the settings, improving user experience.
- Introduced a new notification setting for task comments, allowing users to receive OS notifications when comments are added to tasks.
- Updated relevant interfaces and configuration files to include the new `notifyOnTaskComments` option.
- Enhanced notification handling logic to detect and notify users of new task comments, excluding comments made by the user themselves.
- Updated UI components to support the new notification setting, ensuring a seamless user experience.
- Added a new method in TeamDataService to extract the reviewer from task history events as a fallback when not present in the kanban state.
- Updated TeamDetailView to support adding multiple members at once, improving the member addition process.
- Enhanced TaskCommentInput to display a more user-friendly reply interface with expandable quotes and member badges.
- Improved TaskDetailDialog to show the reviewer information when a task is approved, enhancing task visibility.
- Introduced loading state handling in ChangeReviewDialog and ContinuousScrollView for better user experience during file loading.
- Updated the task assignment message to emphasize the importance of starting tasks promptly, with improved formatting for clarity.
- Revised action mode instructions for the 'delegate' mode to provide clearer guidance on delegation responsibilities and expectations, including the creation of investigation tasks for ambiguous requests.
- Added new protocols in TeamProvisioningService to clarify ownership and task refinement processes during investigations, ensuring better task management and accountability.
- Deleted the TaskCommentForwarding module and its associated functions to simplify the codebase.
- Updated TeamDataService and TeamProvisioningService to remove references to task comment forwarding, ensuring a more straightforward implementation.
- Adjusted unit tests to reflect the removal of task comment forwarding functionality, enhancing clarity and maintainability.
- Added a new function to drop CLI provisioner members from the member map, ensuring these internal artifacts are never displayed to users.
- Updated the createCliProvisionerNameGuard function to unconditionally hide provisioner names, regardless of the presence of base members.
- Modified unit tests to reflect the new behavior of dropping provisioner names even when the base member is absent.
- Implemented deduplication logic in TeamMemberLogsFinder to retain only the largest cumulative subagent snapshots per sessionId and memberName.
- Enhanced MemberLogsTab with a new function to filter chunks based on task work intervals, improving the relevance of displayed logs.
- Updated state management in MemberLogsTab to utilize the new filtering logic for both preview and detail chunks.
- Added unit tests to verify the new deduplication and filtering functionalities.
- Introduced a validation fingerprint mechanism in FileContentResolver to ensure cached content is reused only when both disk content and snippets remain unchanged.
- Reduced cache TTL to 5 seconds for provisional entries to minimize stale data risks.
- Added utility functions for generating fingerprints based on disk content and snippet details.
- Updated cache handling logic to incorporate validation checks, improving efficiency and accuracy in content retrieval.
- Enhanced unit tests to cover new caching behavior and fingerprint validation scenarios.
- Introduced a new `killTeamProcess` function to consistently use SIGKILL for terminating team processes, preventing unintended cleanup of team files.
- Updated multiple instances in `TeamProvisioningService` to utilize `killTeamProcess` for improved clarity and maintainability.
- Enhanced `CreateTeamDialog` and `TeamListView` components to manage team name conflicts more effectively by incorporating active provisioning states.
- Added a fast path in FileContentResolver to skip history lookup for files created by the agent with empty original content.
- Improved loading state in FileSectionDiff to display a loading message and snippet preview when applicable.
- Adjusted header content class names in ClaudeLogsSection and button styles in CollapsibleTeamSection for better UI consistency.
- Refactored ContinuousScrollView to streamline rendering logic for file sections based on content availability.
- Modified comment notification formatting in tasks.js to enhance clarity by using bold text for task references.
- Updated the automated comment notification detection in maintenance.js to align with the new formatting.
- Adjusted test cases to reflect the updated comment structure for consistency in notifications.
- Increased FILE_MENTIONS_CACHE_MAX from 1000 to 10,000 to accommodate larger datasets.
- Introduced DISCOVERY_CACHE_TTL to optimize project session discovery by caching results.
- Updated findMemberLogs method to accept an optional mtimeSinceMs parameter for filtering logs based on modification time.
- Added lastOutputPreview to MemberLogSummary for displaying the last assistant output in logs.
- Implemented displayMemberName utility function to standardize member name display across various components.
- Updated multiple components to utilize displayMemberName for consistent member name rendering.
- Introduced a new method to collect subagent file candidates, streamlining the file scanning process.
- Implemented parallel processing of subagent files with a concurrency limit to enhance performance.
- Improved error handling during file parsing, ensuring that failures do not disrupt the overall scanning process.
- Added unit tests to verify that member logs are returned sorted by start time in descending order.
- Increased FILE_MENTIONS_CACHE_MAX from 200 to 1000 to accommodate larger datasets.
- Introduced SCAN_CONCURRENCY constant to limit the number of concurrent file reads during scans, optimizing performance.
- Refactored file scanning logic to collect candidate files more efficiently and process them in parallel.
- Added new SubagentAttribution interface to standardize the structure of attribution results.
- Expanded unit tests to validate the new file reference retrieval logic for tasks, ensuring accurate member identification across teams.
- Replaced logger.info calls with console.log in TeamMemberLogsFinder for performance logging.
- Simplified environment variable handling in TeamProvisioningService by removing unnecessary context settings.
- Updated stopTeam method to accept a signal parameter for improved process termination control.
- Enhanced model handling in team dialogs to support new context management logic, ensuring consistent behavior across components.
- Adjusted teamSlice to reflect changes in model parsing and context handling, improving overall state management.
- Replaced references to extended context with limit context in TeamProvisioningService and related components, ensuring consistent terminology.
- Updated LaunchTeamDialog and CreateTeamDialog to reflect the new limit context functionality, enhancing user clarity.
- Removed the deprecated ExtendedContextCheckbox component and integrated its functionality into the new LimitContextCheckbox.
- Adjusted teamSlice to accommodate changes in launch parameters, streamlining the context management process.
- Updated task management instructions in tasks.js to clarify the process for handling newly assigned tasks that must wait due to ongoing work, emphasizing the importance of leaving comments with reasons and estimated completion times.
- Improved member briefing messages to include critical reminders about task status and comment handling.
- Enhanced TeamDataService to implement task comment notification features, ensuring leads are notified of teammate comments on tasks.
- Refactored related UI components to support better interaction and visibility of task statuses and notifications.
- Introduced a new system for collecting and prioritizing detection signals for team members, improving accuracy in identifying the correct member from logs.
- Added a `DetectionSignal` interface and a `SIGNAL_PRECEDENCE` array to define the order of reliability for different signal sources.
- Refactored the `attributeSubagent` method to collect signals instead of immediately determining the detected member, allowing for better decision-making based on signal precedence.
- Implemented a new static method `selectBestSignal` to determine the most reliable member signal based on the defined precedence.
- Expanded unit tests to validate the new signal handling logic and ensure correct member identification under various scenarios.
- Updated the detection priority logic for teammate identification to ensure that the teammate ID is recognized as a message sender rather than the file owner.
- Changed the priority threshold from 3 to 2 to allow for more accurate routing of messages based on sender identification.
- Updated task notification messages to include clearer formatting, emphasizing task status changes.
- Enhanced TeamProvisioningService to include a new `configReady` state, improving tracking of provisioning progress.
- Refactored the handling of team selection to prevent duplicate fetches during loading states, ensuring smoother user experience.
- Improved UI components for better interaction and visibility of task and team states.
- Updated task management instructions in tasks.js and TeamProvisioningService.ts to clarify the process for handling follow-up work on tasks.
- Enhanced member briefing and task status protocols with critical reminders to ensure proper task handling.
- Refactored TeamDetailView to improve data consistency and tab management.
- Simplified MessagesPanel by integrating team status and pending replies for better user experience.
- Enhanced MarkdownViewer and ActivityItem components to support team click actions and improve interactivity.
- Introduced stable member management hooks to optimize rendering performance in team activity components.
- Updated task management instructions in tasks.js and TeamProvisioningService.ts to emphasize the importance of moving tasks to in_progress before performing follow-up work.
- Added critical reminders in member briefing and task status protocols to ensure proper task handling and prevent issues with comment-driven work.
- Refactored TeamDetailView to improve tab management and data consistency after hot module replacement.
- Simplified MessagesPanel by integrating the StatusBlock component, enhancing the display of team status and pending replies.
- Cleaned up teamSlice by removing unnecessary functions and ensuring default model handling for team launch parameters.
- Introduced global hunk offset and total review hunks properties in ChangeReviewDialog, ContinuousScrollView, FileSectionDiff, and CodeMirrorDiffView components to enhance the review experience.
- Updated related components to utilize these new properties for better tracking and display of review progress across multiple files.
- Improved floating toolbar functionality in CodeMirrorDiffView to reflect the current hunk index and total count, enhancing user interaction during code reviews.
- Added new functions for member briefing, allowing retrieval of member-specific instructions and context based on team configuration and metadata.
- Enhanced the TeamProvisioningService to include prompts for new members, emphasizing the importance of calling the member briefing tool during onboarding.
- Updated tests to validate the new member briefing functionality and ensure proper handling of various member scenarios, including inbox presence and metadata resolution.
- Introduced environment variable support for enabling or disabling member briefing bootstrap prompts during team member provisioning.
- Updated CreateTeamDialog to include automatic team name suggestions and improved default team description handling.
- Enhanced member management with new utility functions for building member draft suggestions and color maps.
- Integrated task and team mention suggestions into MembersEditorSection and MemberDraftRow for better user experience.
- Refactored UI components for improved styling and functionality, ensuring consistent behavior across team management features.
- Added clarifications to critical execution instructions, emphasizing the prohibition of certain agent tool calls during initial team provisioning and reconnecting processes.
- Removed disallowed tools from the configuration to streamline the provisioning workflow and prevent unintended actions.
- Updated TeamProvisioningService to clarify team creation steps and critical execution instructions for non-interactive CLI sessions.
- Improved error handling and process management to prevent unintended file deletions during process termination.
- Enhanced UI components in TeamDetailView and ProvisioningProgressBlock for better user experience and visibility of CLI logs.
- Refactored KanbanColumn styling for improved layout consistency and accessibility.
- Added logic to manage visibility of CLI logs based on the spawning process state.
- Added runtime control API to manage team lifecycle, including launch and stop functionalities.
- Integrated runtime state retrieval to provide current status of teams.
- Enhanced tests to validate the new runtime control features, ensuring proper functionality and error handling.
- Updated type definitions to include runtime API methods for better type safety and clarity in team management.
- Added isOnline property to CrossTeamTarget and updated CrossTeamService to sort targets based on online status.
- Enhanced MessageComposer to fetch and display online status of teams, improving user experience in cross-team messaging.
- Updated various UI components to reflect changes in team online status, including visual indicators in the MessagesPanel and MessageComposer.
- Improved error handling and validation messages in CreateTeamDialog and other forms for better user feedback.
- Refactored CSS for field-level validation to enhance visual consistency across forms.
- Updated utility functions to support new online status features in team management.
- Modified IPC handlers to return structured snapshots for lead activity, lead context usage, and member spawn statuses, enhancing data consistency.
- Introduced new types for LeadActivitySnapshot, LeadContextUsageSnapshot, and MemberSpawnStatusesSnapshot to improve type safety and clarity.
- Refactored TeamProvisioningService to manage provisioning runs more effectively, including updates to state management for active runs.
- Enhanced UI components to utilize the new data structures, improving the overall user experience in team management features.
- Integrated the @radix-ui/react-alert-dialog package for improved alert dialog functionality.
- Updated SkillImportService to include a new inspectSourceDir method for enhanced file inspection and warning generation during skill imports.
- Refactored existing methods to streamline file reading and directory walking processes, improving overall performance and error handling.
- Added new SkillPlanService to manage skill upsert plans, enhancing the skills mutation workflow.
- Updated UI components to support new features and improve user experience in the skills management interface.
- Introduced skills catalog management with functionalities to list, get details, preview, and apply skill changes.
- Implemented IPC handlers for skills-related actions, enhancing communication between renderer and main processes.
- Updated the UI to include a dedicated Skills panel within the extension store, improving user access to skills management.
- Added new constants and types for skills API integration, ensuring a structured approach to skills handling.
- Enhanced state management to support skills loading, error handling, and detail fetching.
Restore terminal task-change badges quickly across restarts without trusting stale snapshots, and keep kanban card review actions compact so important controls fit reliably on one row.
Made-with: Cursor
- Added a 'source' field to PluginCatalogItem to distinguish between official and third-party plugins.
- Refactored ChangeExtractorService to improve caching mechanisms and normalize file paths for better consistency.
- Updated TaskBoundaryParser to support task IDs with underscores, enhancing task identification.
- Enhanced TeamMcpConfigBuilder to merge user-defined MCP configurations with generated ones, improving configuration management.
- Improved UI components to display source information for plugins and MCP servers, enhancing user experience and clarity.
- Introduced a new structured task reference format `{ taskId, displayId, teamName }` for consistent task mention persistence across UI and storage.
- Enhanced message handling in various components to support the new task reference structure, including normalization and validation.
- Updated task-related functions to accommodate optional task reference fields, improving task management and messaging capabilities.
- Improved rendering and navigation of task references in the UI, ensuring stable links across messages and comments.
- Refactored task reference utilities for better integration and usability within the application.
- Added new optional parameters 'createdBy' and 'from' to the task creation function for better tracking of task origins.
- Updated task execution logic to include the new parameters, improving task metadata handling.
- Enhanced tests to validate the new parameters and ensure correct task creation behavior.
- Refactored related components to accommodate the changes in task management, ensuring a seamless user experience.
- Added McpHealthDiagnosticsService to manage health checks for MCP servers.
- Implemented IPC channels for diagnosing MCP server health, including new MCP_REGISTRY_DIAGNOSE channel.
- Enhanced UI components to display diagnostic status and results for installed MCP servers.
- Updated state management to track MCP diagnostics loading state and errors.
- Improved overall user experience with real-time feedback on MCP server connectivity and health status.
- Introduced new parameters for cross-team messaging, including CROSS_TEAM_SENT_SOURCE for better tracking of sent messages.
- Updated sendCrossTeamMessage function to append sent messages to the message store, ensuring a complete history of communications.
- Enhanced tests to validate the new message storage functionality and ensure accurate retrieval of sent messages.
- Improved handling of message timestamps and deduplication logic for cross-team communications.
- Introduced a summaryOnly option in the API for fetching task changes, allowing for lightweight responses that skip detailed snippets and timelines.
- Enhanced ChangeExtractorService to utilize the summaryOnly option, improving performance by conditionally caching task change data.
- Updated related components and services to support the new summaryOnly feature, ensuring consistent behavior across the application.
- Improved state management in TaskDetailDialog for task changes, including loading and error handling enhancements.
- Updated README to include new 'Solo mode' feature for single-agent task management.
- Refactored message handling in TeamDataService and TeamProvisioningService to improve deduplication of lead messages.
- Enhanced linkification in chat components to support team mentions.
- Introduced AnimatedHeightReveal for smoother task item animations in the sidebar.
- Improved task comment input to support chip draft persistence and team suggestions.
- Cleaned up CSS by removing unused animations related to task item entry.
- Introduced ApiKeyService for managing API keys, including listing, saving, deleting, and looking up values.
- Added IPC channels for API key operations and integrated them into the Electron API.
- Implemented GitHub stars fetching for MCP servers, enhancing visibility of repository popularity.
- Updated UI components to display GitHub stars and API key management features, including a dedicated API Keys tab.
- Enhanced McpInstallService to support custom MCP server installations with improved validation and error handling.
- Refactored various components to accommodate new features and improve user experience.
- Updated handleAddMember function to include optional 'workflow' parameter with validation.
- Introduced ensureMemberInMeta method in TeamDataService to migrate members from config.json to meta if necessary.
- Refactored addMember and removeMember methods to utilize ensureMemberInMeta for improved member management.
- Enhanced TeamProvisioningService to ensure message handling includes workflow context in notifications.
- Added functionality to mark delivered cross-team messages as read and restore reply hints in TeamProvisioningService.
- Introduced a new method to extract user text from incoming messages for better processing of native teammate messages.
- Removed outdated methods related to cross-team target team parsing to streamline the service.
- Enhanced tests to validate the new message handling and ensure proper functionality in live scenarios.
- Added optional parameters 'conversationId' and 'replyToConversationId' to the cross-team messaging tool for improved threading.
- Updated the TeamMemberResolver to ignore tool-like cross-team inbox names, ensuring cleaner member resolution.
- Enhanced TeamProvisioningService to handle explicit cross-team reply instructions and prevent relaying tool-like names.
- Improved tests to validate new cross-team messaging features and recipient handling, ensuring robust functionality across services.
- Refactored cross-team message formatting to use a canonical XML-like tag structure for improved clarity and consistency.
- Introduced new attributes for cross-team messages, including 'from', 'depth', 'conversationId', and 'replyToConversationId'.
- Enhanced TeamProvisioningService to manage pending cross-team reply expectations, ensuring proper message handling and relay.
- Updated UI components to reflect changes in cross-team messaging, including stripping metadata from displayed messages.
- Added tests to validate new cross-team message handling and ensure proper functionality across services.
- Added clarification on handling review requests in TeamProvisioningService to prevent redundant notifications.
- Introduced a new utility function to compute remaining context in contextMath, improving context management.
- Updated ChatHistory component to display remaining context urgency and percentage.
- Enhanced UserChatGroup with improved expand/collapse functionality and sticky "Show less" button.
- Updated tests to validate new context handling and messaging instructions.
- Added functionality to track member spawn statuses during team provisioning, including marking members as online when their first inbox message arrives.
- Introduced new IPC channels and handlers for fetching member spawn statuses.
- Enhanced TeamProvisioningService to manage spawn status updates and emit events for changes.
- Updated UI components to reflect member spawn statuses, improving visibility of member activity during provisioning.
- Added CSS animations for member spawn effects to enhance user experience.
- Added action mode validation in cross-team and team messaging handlers to ensure only valid modes ('do', 'ask', 'delegate') are accepted.
- Enhanced MessageComposer and TeamDetailView to support action mode selection and pass it through to message sending functions.
- Introduced utility functions to build action mode-specific message content for better clarity in communication.
- Updated tests to cover action mode scenarios, including validation and handling of invalid modes.
- Improved user experience by integrating action mode instructions into message delivery for leads.
- Updated TeamDataService to attach kanban compatibility with reviewer information for tasks.
- Introduced new utility functions in TeamMemberResolver and TeamProvisioningService to handle cross-team pseudo recipients and improve member resolution.
- Enhanced ActivityTimeline and Member components to display current and review tasks more effectively.
- Added tests to validate the handling of cross-team inbox names and task assignments.
- Improved MessageComposer to support action mode selection for lead recipients.
- Introduced logic to prevent relaying cross-team replies back into the originating lead, ensuring cleaner message handling.
- Added utility functions for parsing cross-team recipients and determining targets for cross-team messages.
- Updated ActivityItem and TeamProvisioningService to utilize new parsing methods for improved recipient qualification.
- Enhanced tests to validate the handling of cross-team replies and recipient parsing.
- Introduced a new method to avoid duplicate member names in TeamMemberResolver, ensuring case-insensitive uniqueness.
- Updated ActivityItem and ActivityTimeline components to utilize local member names for improved recipient qualification checks.
- Added tests to validate the handling of dotted names and deduplication in cross-team messaging scenarios.
- Use getTeamColorSet/nameColorSet for accurate team colors matching
SortableTab and TeamDetailView approach
- Always show team color dot, including next to cross-team lead badges
- Remove hash-based resolveTeamColor fallback in favor of real config colors
- Clean up unused imports (ArrowRightLeft, selectedTargetColor)
- Add TeamMemberResolver and TeamProvisioningService enhancements with tests
- Added messageId and timestamp fields to CrossTeamSendRequest for better message tracking.
- Updated CrossTeamService to utilize these fields when sending messages, ensuring consistent message identity.
- Enhanced TeamProvisioningService to support cross-team sender functionality, allowing for improved message handling.
- Introduced parsing for cross-team reply prefixes to manage threaded conversations effectively.
- Updated tests to validate the inclusion of messageId and timestamp in cross-team messages.
- Introduced a new caching mechanism for task changes in ChangeExtractorService to improve performance and reduce redundant data fetching.
- Updated TeamInboxWriter to preserve message identity fields such as messageId and timestamp for better deduplication across live and persisted messages.
- Enhanced SendMessageRequest interface to include additional fields like color, toolSummary, and toolCalls for richer message context.
- Improved log file reference resolution in TeamMemberLogsFinder to include filePath for better tracking of log sources.
- Added leadName and leadColor properties to CrossTeamTarget and related interfaces for better team representation.
- Implemented caching for file mentions in TeamMemberLogsFinder to improve performance and reduce redundant file checks.
- Introduced deriveSinceMs method to calculate log search boundaries based on task creation times.
- Updated UI components to display lead information where applicable, enhancing user experience in messaging and logs.
- Introduced conversationId and replyToConversationId to support threaded replies in cross-team messages.
- Updated message formatting to include conversation metadata in the message prefix.
- Enhanced CrossTeamService to infer conversation metadata when not explicitly provided.
- Improved tests to validate the handling of conversation IDs and ensure correct message routing.
- Updated UI components to display pending replies and manage cross-team interactions more effectively.
- Deleted the obsolete electron.vite.config file to streamline the project structure.
- Updated package.json to remove the "agent-teams-controller" dependency and added "@radix-ui/react-hover-card".
- Enhanced the pnpm-lock.yaml to reflect the updated dependencies.
- Modified CrossTeamService and TeamProvisioningService to accommodate new color properties in team configurations.
- Improved message handling in various components to support mention links and member hover cards.
- Added deduplication logic to prevent recent equivalent cross-team messages from being sent multiple times.
- Introduced functions to normalize message content and build deduplication keys.
- Updated CrossTeamService and CrossTeamOutbox to utilize deduplication during message sending.
- Enhanced tests to verify deduplication behavior and ensure correct message handling in various scenarios.
- Team selector dropdown in MessageComposer (left of recipient selector)
- Cross-team mode locks recipient to team-lead, disables attachments
- Sender copy written to fromTeam inbox with source 'cross_team_sent'
- Purple accent styling for cross-team messages (incoming + outgoing)
- "from team-x" / "to team-x" badges in ActivityItem
- Strip [Cross-team from ...] prefix in UI (kept in stored text for CLI)
- CSS variables for cross-team theme (dark + light)
- Store: fetchCrossTeamTargets (all teams), sendCrossTeamMessage action
- Tests updated for sender copy and formatted text prefix
- Updated TeamProvisioningService to mirror provisioning narration into the live cache, allowing visibility in Messages/Activity.
- Modified TeamDetailView to include current lead session ID for better context in team interactions.
- Enhanced ActivityTimeline to suppress reconnect boundaries based on current lead session ID, improving session clarity.
- Adjusted MessageComposer to clarify provisioning status in UI messages and placeholders, enhancing user awareness during team launches.
- Updated TeamProvisioningService to prevent duplicate display of provisioning narration in the Activity timeline.
- Enhanced CompactBoundary component with a cleaner design and improved interaction for expanding/collapsing content.
- Added new CSS variables for compact phase badge styling to enhance visual consistency.
- Modified TeamDetailView to include a collapsible status block for better organization of team information.
- Improved MessageComposer to reflect provisioning status in placeholders and notifications, enhancing user awareness during team launches.
- Updated ActivityTimeline to suppress session separators for reconnects within the same team, streamlining the user experience.
- Enhanced the startTask function to clear stale kanban entries when a task is reopened, ensuring accurate task tracking.
- Updated the addTaskComment function to handle notification failures gracefully, allowing comments to persist even if owner notifications fail.
- Added tests to validate the resilience of task comment notifications and ensure correct behavior under failure scenarios.
- Refactored related functions for improved clarity and maintainability in task management.
- Introduced a new function to notify task owners on comments from other members, improving communication and responsiveness.
- Updated existing comment handling functions to include logic for notifying owners based on comment type and author.
- Added tests to validate the new notification behavior, ensuring that owners are correctly alerted for relevant comments while avoiding unnecessary notifications for self-comments.
- Refactored task management logic to streamline comment processing and notification handling.
- Introduced a new function to determine the current review state based on task history events, improving the accuracy of review status tracking.
- Updated the requestReview, approveReview, and requestChanges functions to append corresponding review events to the task history, ensuring comprehensive tracking of review actions.
- Refactored task management logic to utilize the new historyEvents structure, replacing the previous statusHistory implementation for better clarity and maintainability.
- Enhanced tests to validate the new review event handling and ensure correct behavior across various task states.
- Added 'needsFix' as a new review state to improve task tracking and management.
- Updated kanban and task handling functions to accommodate the new review state, including modifications to clearKanban and task status updates.
- Enhanced task briefing output to include sections for tasks needing fixes, pending tasks, and approved tasks, improving clarity in task management.
- Updated UI components to display the 'needsFix' state appropriately across various views, including task rows and tooltips.
- Refactored tests to cover new functionalities related to the 'needsFix' state, ensuring comprehensive coverage of task management scenarios.
- Refactored task creation logic to support explicit immediate start and maintain default pending status.
- Implemented notification system for task owners upon assignment, including detailed task instructions.
- Enhanced task briefing output to provide a compact view of assigned tasks, differentiating between in-progress, pending, and completed tasks.
- Added utility functions for better task management and streamlined task reference handling.
- Updated tests to cover new task assignment notifications and briefing functionalities, ensuring accurate task status representation.
- Added a new method to create and push live lead messages during team provisioning, enhancing real-time communication.
- Updated the event handling to ensure lead-message events only refresh team details, preventing unnecessary updates to team/task lists.
- Improved error handling in team data refresh to preserve existing data during provisioning and transient errors.
- Enhanced tests to cover new lead-message functionality and ensure proper behavior during team provisioning scenarios.
- Cron-based task scheduling with SchedulerService (create, pause, resume, delete)
- One-shot executor using `claude -p` with stream-json output for rich log display
- CLAUDECODE env var stripped to prevent nested session detection
- JsonScheduleRepository for persistent schedule/run/log storage
- Full IPC pipeline: handlers, preload bridge, API types, HttpClient stubs
- ScheduleSection UI with create/edit dialog, run history, status badges
- ScheduleRunLogDialog with CliLogsRichView (thinking blocks, tool cards, markdown)
- Real-time run status updates via store subscription
- Retry logic with configurable max retries and auto-pause on consecutive failures
- CronScheduleInput with human-readable descriptions via cronstrue
- 3 test suites: SchedulerService, ScheduledTaskExecutor, JsonScheduleRepository
- Replaced legacy references with new runtimeHelpers in context, processStore, tasks, and review modules for improved maintainability.
- Introduced leadSessionId handling in review requests and approvals, ensuring consistent tracking of session identifiers across operations.
- Added new utility functions in runtimeHelpers for path management and process checks, streamlining task-related functionalities.
- Updated tests to validate the inclusion of leadSessionId in various workflows, enhancing the robustness of the messaging system.
- Removed legacy overlay review state handling from taskStore, simplifying task normalization processes.
- Updated task retrieval methods to directly use normalized task data without fallback to legacy kanban states.
- Eliminated outdated tests related to legacy kanban overlay, focusing on modern task management mechanisms.
- Refactored TeamDataService and TaskBoundaryParser to enhance clarity and maintainability by removing unnecessary complexity.
- Updated related types and interfaces to reflect the removal of legacy support.
- Updated the `getTeamData` method to accept an options parameter, allowing for conditional inclusion of messages in the response.
- Modified the `handleGetData` function to validate and process the new options, improving flexibility in data retrieval.
- Enhanced the `TeamDetailView` and message components to handle loading states and display messages based on the new options.
- Introduced a loading delay for messages to optimize UI performance during data fetching.
- Updated relevant types and interfaces to support the new options structure.
- Added `ensureStableMessageIds` method to assign deterministic IDs to messages lacking a messageId, ensuring stability across UI updates.
- Introduced `normalizeMessageIdPart` for consistent message ID formatting.
- Enhanced `buildTeammateAgentBlockReminder` function to provide clear internal instructions for handling agent-only messages.
- Updated tests to verify the inclusion of hidden-instruction block rules in team prompts.
- Introduced a new `wrapAgentBlock` function to standardize the formatting of agent-only messages across the application.
- Updated the `requestReview` method to utilize the new agent block format, enhancing consistency in review request messages.
- Refactored legacy agent block handling to support both new XML-like and legacy fenced formats, ensuring backward compatibility.
- Enhanced tests to validate the new agent block formatting and ensure proper extraction of agent-only content from messages.
- Updated the addTaskComment method to include the author as 'user' for better context in task comments.
- Enhanced error handling in TeamProvisioningService during MCP config file writing to ensure proper cleanup on failure.
- Improved user interface elements in TeamDetailView and AddMemberDialog for better accessibility and responsiveness.
- Refined mention handling in MentionableTextarea to allow for smoother user interactions with task references.
- Adjusted CSS styles for better visual contrast in light theme, enhancing overall user experience.
- Updated the check:workspace script to include end-to-end testing for the MCP package.
- Added a new test:e2e script in the MCP server for running end-to-end tests.
- Refactored controller import logic to support default exports from the agent-teams-controller.
- Improved team deletion handling in IPC by ensuring team provisioning is stopped before deletion.
- Introduced a function to resolve the real node binary path for better compatibility in Electron environments.
- Enhanced task display in MemberCard and TaskDetailDialog components for improved user experience.
- Reintroduced the TEAM_VALIDATE_CLI_ARGS constant in IPC channels for consistency.
- Updated type definitions in TaskBoundaryParser to use a new DetectedMechanism type for better clarity and maintainability.
- Improved error handling in TeamProvisioningService by ensuring exit codes are converted to strings for clearer error messages.
- Standardized imports of CliArgsValidationResult across multiple files to maintain consistency in type usage.
- Added maintenance module to the agent-teams-controller, enabling the reconciliation of stale kanban entries and linked inbox comments.
- Implemented garbage collection logic in kanbanStore to remove invalid task references and clean up column orders.
- Updated controller to expose maintenance functionalities, allowing for better task and comment management.
- Enhanced tests to validate the new reconciliation process, ensuring idempotency and correctness in handling stale data.
- Integrated new CLI argument options for worktree and custom arguments in team launch and creation dialogs, improving user flexibility.
- Added requestReview method to facilitate task review requests, integrating with kanban and messaging systems.
- Updated taskStore to manage review states, ensuring compatibility with kanban columns.
- Enhanced message handling by introducing appendSentMessage for better tracking of sent messages.
- Improved task management by normalizing review states and integrating them into task creation and retrieval processes.
- Updated tests to cover new review and messaging features, ensuring robust functionality across components.
- Added agent-teams-controller as a dependency and updated the bundling configuration to exclude it.
- Refactored task management functions to utilize the new taskStore, improving code organization and maintainability.
- Introduced new methods for handling task states, including soft deletion and restoration.
- Enhanced kanban functionality with improved reviewer management and task column updates.
- Updated tests to reflect changes in task creation and approval processes, ensuring robust coverage.
- Improved task ID handling and display logic for better user experience across components.
- useNewItemKeys: replace useRef with useState to fix react-hooks/refs
errors, add missing paginationKey dependency, use derive-state-during-render
pattern for resetKey, wrap commit step in queueMicrotask
- TeamProvisioningService: re-arm pendingPostCompactReminder in second
idle guard after async work so reminder is deferred instead of dropped
- Added new workspace commands for type checking, building, and testing across multiple packages.
- Updated CI workflow to include paths for new packages and utilize workspace commands.
- Refactored MCP server to integrate with the agent-teams-controller, enhancing task management capabilities.
- Improved task boundary detection and logging for MCP tools, ensuring better tracking of task states.
- Updated documentation and prompts to reflect new MCP tool usage, replacing previous teamctl.js references.
- Fix import sorting (simple-import-sort) in 10+ files
- Remove unnecessary type assertions in TeamProvisioningService, store/index
- Extract nested template literals in httpClient.ts
- Fix react-hooks/refs violations: replace render-time ref access with
useState + "adjust state during render" pattern in ActivityTimeline,
TaskCommentsSection, AnimatedHeightReveal
- Fix react-hooks/rules-of-hooks: move conditional hooks above early returns
in ActivityTimeline, ToolApprovalSheet
- Fix react-hooks/set-state-in-effect: wrap synchronous setState in
queueMicrotask in useComposerDraft, MessageComposer, AttachmentPreviewList,
ToolApprovalSheet
- Fix react-hooks/exhaustive-deps: destructure draft properties before
useCallback in MessageComposer, copy ref values in AttachmentPreviewList
- Fix no-param-reassign: use Object.assign in ToolApprovalSheet, local
variable in AnimatedHeightReveal
- Fix sonarjs violations: remove void operator, reduce nesting in
LeadThoughtsGroup; remove unused import in CliLogsRichView
- Use RegExp.exec() instead of String.match() in FileLink
- Use optional chain in streamJsonParser with eslint-disable for TS conflict
- Refactored notification handling to utilize NotificationManager for team events, improving consistency and reducing duplicate notifications.
- Introduced deduplication keys for notifications to prevent storage of identical messages.
- Updated notifyNewInboxMessages and notifyNewSentMessages functions to streamline message processing and enhance user experience.
- Enhanced rate limit message handling with in-memory tracking to prevent re-notification of deleted messages.
- Improved UI components with new animations and consistent styling for better user engagement.
- Added support for team-specific notifications, including new event types and improved error handling in notifications.
- Improved post-compact reminder handling in TeamProvisioningService to preserve pending reminders during compact boundaries and ensure proper state management on errors.
- Updated SendMessageDialog to remove the summary field, simplifying the message submission process and ensuring the message body is used consistently.
- Enhanced MemberCard styling with a gradient background for better visual appeal.
- Adjusted MemberList layout to dynamically adapt based on sidebar state, improving user experience in member display.
- Added tests to validate new reminder logic and ensure live config updates are reflected in reminders.
- Replaced hardcoded maximum lengths for comments and messages with a centralized constant `MAX_TEXT_LENGTH` for consistency across components.
- Enhanced README to provide a brief overview of the project.
- Introduced a new function to build a compact members roster for improved team member display in reminders.
- Added support for displaying image attachments from comments in the task detail dialog.
- Updated session and subagent route handlers to support an optional `bypassCache` query parameter, allowing clients to bypass cached responses.
- Enhanced README to include a Discord link for community engagement.
- Improved CSS for lightbox toolbar buttons to address macOS hit-testing issues.
- Refactored task ID linkification in markdown to ensure accurate matching and improved functionality in various components.
- Introduced EffortLevel type to define valid effort levels ('low', 'medium', 'high').
- Updated TeamCreateRequest and TeamLaunchRequest interfaces to include effort parameter.
- Enhanced CreateTeamDialog and LaunchTeamDialog to allow users to select effort levels.
- Integrated effort level handling in provisioning requests and responses within TeamProvisioningService.
- Removed auto-focus effect in ToolApprovalSheet for improved user experience.
- Added support for tool approval requests and responses in the team provisioning service.
- Introduced IPC channels for handling tool approval events between main and renderer processes.
- Enhanced the UI to display tool approval requests and allow user responses through new components.
- Updated team launch and creation dialogs to include an option for skipping permissions, integrating with the new tool approval logic.
- Implemented state management for pending approvals in the store, ensuring a seamless user experience during tool interactions.
- Added `strip-markdown` package to handle markdown formatting in plain-text contexts.
- Updated `teams.ts` and `NotificationManager.ts` to use `stripMarkdown` for truncating notification bodies and error messages, enhancing readability.
- Introduced `textFormatting.ts` utility for markdown stripping functionality.
- Enhanced `GlobalTaskList` component with sorting options and improved UI for task management.
- Implemented localStorage persistence for collapsed group states in `useCollapsedGroups` hook.
- Fix import sort order in 6 files (TeamDataService, TeamProvisioningService,
ChatHistory, SortableTab, LeadThoughtsGroup, MemberDraftRow)
- Replace slow regex with string manipulation in MemberStatsComputer
- Use RegExp.exec() instead of String.match() in toolSummary
- Fix non-backtracking regex pattern in toolSummary parser
- Remove unnecessary type assertions in TeamDataService and TeamProvisioningService
- Convert for-loop to for-of in TeamDataService
- Fix no-param-reassign in TeamDataService.sendMessage
- Convert function component to arrow function in LeadThoughtsGroup
- Fix nested functions depth in MentionableTextarea tip rotation
- Use optional chain in teamSlice
- Refactored TeamDataService and TeamProvisioningService to replace tool usage counts with structured tool call details, improving accuracy and clarity in tool tracking.
- Introduced ToolCallMeta type for better representation of tool call metadata, including name and preview.
- Updated tool summary generation to utilize new tool call details, enhancing the visibility of tool interactions in messages.
- Enhanced LeadThoughtsGroupRow to aggregate tool calls for improved tooltip display, providing users with clearer insights into tool usage.
- Modified UI components to accommodate changes in tool summary handling, ensuring a consistent user experience.
- Added new dependencies for mcp-server in pnpm-lock.yaml, including fastmcp and zod.
- Updated pnpm-workspace.yaml to include mcp-server in the workspace packages.
- Modified TeamDataService and TeamProvisioningService to exclude 'SendMessage' from tool usage counts, improving accuracy in tool tracking.
- Enhanced ChatHistory component to display context injection percentages, improving user feedback on context usage.
- Updated TeamDetailView to ensure session details are fetched periodically for active tabs, enhancing data freshness.
- Improved ActivityTimeline styling for better visual separation of sessions and messages.
- Replaced buildToolSummary with formatToolSummaryFromMap in TeamDataService and TeamProvisioningService to streamline tool summary generation.
- Enhanced JSONL file path handling in TeamDataService to accommodate variations in project directory naming.
- Introduced pendingToolCounts in TeamProvisioningService to accumulate tool usage data for better message context.
- Updated SortableTab and DragOverlayTab components for improved styling and responsiveness.
- Adjusted ClaudeLogsSection to refine log display height for better usability.
- Enhanced TeamDetailView to filter out lead-to-user messages temporarily, improving message clarity.
- Added model selection UI in MemberDraftRow with informative tooltips for user guidance.
- Improved MentionableTextarea with rotating tips to enhance user experience during message composition.
- Added tool summary generation in TeamDataService and TeamProvisioningService to capture tool usage details in messages.
- Updated InboxMessage type to include toolSummary for better tracking of tool usage in assistant messages.
- Enhanced LeadThoughtsGroupRow to aggregate and display total tool usage across thoughts, improving visibility of tool interactions.
- Refactored TeamModelSelector to incorporate provider icons and improve user interface for model selection.
- Updated README and CLAUDE.md to reflect new command usage and features related to tool summaries.
- Refactored isValidFilePath function to improve validation logic, including trimming whitespace and stripping trailing punctuation.
- Updated MemberStatsComputer to filter out invalid file paths from perFileStats, ensuring only valid paths are included in the final stats.
- Added unit tests for isValidFilePath to cover various edge cases, enhancing reliability of file path handling.
- Improved overall code readability and maintainability in MemberStatsComputer.
- Updated handleGetSessionDetail and handleGetSubagentDetail functions to accept an optional options parameter for bypassing cache.
- Modified IPC and API methods to support the new options parameter, enhancing flexibility in data retrieval.
- Adjusted MemberLogsTab to utilize the bypassCache option when fetching log details, improving data freshness.
- Updated message deduplication logic in handleGetData to exclude lead_process messages with a 'to' field.
- Added source field to message payloads in TeamAgentToolsInstaller for system notifications.
- Enriched sendMessage function in TeamDataService with leadSessionId for better session tracking.
- Improved UI components including MessageComposer placeholder text and scroll behavior in ActivityTimeline.
- Enhanced LeadThoughtsGroupRow to support live indicators and auto-scroll functionality for new messages.
- Implemented lead session ID propagation in TeamDataService to enrich inbox messages without existing leadSessionId.
- Added source and leadSessionId fields to message payloads in TeamInboxReader for better tracking.
- Updated CSS for compact CLI logs display, improving item density in the UI.
- Refactored CliLogsRichView and LeadThoughtsGroupRow to support new UI features and enhance message visibility.
- Adjusted ActivityTimeline to include zebra striping for better readability of messages.
- Updated handleGetData to collect text fingerprints from all message sources for deduplication of lead_process messages.
- Removed outdated leadSessionId assignment logic in TeamDataService to streamline message processing.
- Enhanced CollapsibleTeamSection and TeamDetailView to support an afterBadge prop for additional UI elements.
- Refactored ActivityTimeline to optimize pagination by excluding lead thoughts from visible message counts.
- Improved LeadThoughtsGroup to ensure single thoughts are rendered as distinct groups, enhancing clarity in the timeline.
- Enhanced TeamDataService to include a 'source' field in message payloads, specifically for system notifications.
- Updated InboxMessage type to accommodate the new 'system_notification' source.
- Modified TeamInboxWriter to conditionally include the source field in the message payload.
- Added tests to verify the inclusion and omission of the source field based on request parameters.
- Refactored TeamDataService to improve lead session message handling, including deduplication logic to prevent double-rendering of messages.
- Added leadSessionId to InboxMessage type for better session tracking.
- Updated ActivityTimeline to visually separate messages by session, enhancing user experience.
- Improved LeadThoughtsGroupRow to support live indicators and auto-scroll functionality for new messages.
- Enhanced AddMemberDialog, LaunchTeamDialog, and MemberDraftRow with updated placeholder text for clarity.
- Remove commented-out code in TeamProvisioningService and MemberCard
(sonarjs/no-commented-code)
- Revert useAttachments keyRef sync from useEffect back to direct
render assignment to avoid stale closure race, suppress react-hooks/refs
- Updated ProvisioningRun interface to include leadTurnSeq and leadTurnMessageTimestamp for better tracking of lead messages.
- Refactored pushLiveLeadProcessMessage to handle message updates and prevent duplicates.
- Introduced removeLiveLeadProcessMessage for better management of live lead messages.
- Enhanced ActivityTimeline to group lead thoughts into collapsible blocks and improve zebra striping logic.
- Updated MemberLogsTab to support quick previews from lead sessions, enhancing task visibility.
- Fix React hooks violations: ref updates during render (useDraftPersistence,
useChipDraftPersistence, useAttachments), setState in effects across 15+
components, useCallback self-reference TDZ in useResizableColumns
- Fix TypeScript lint: remove unnecessary type assertions, replace inline
import() annotations with direct imports, remove unused variables/imports
- Fix SonarJS issues: prefer-regexp-exec, slow-regex in SubagentResolver,
no-misleading-array-reverse in TeamProvisioningService, use-type-alias
in ClaudeLogsSection, variable shadowing in ChangeExtractorService
- Fix accessibility: associate labels with controls in filter popovers
- Fix template expression safety: wrap unknown errors with String()
- Fix flaky FileWatcher test: floor instanceCreatedAt to second granularity
to match filesystem birthtimeMs resolution on Linux
- Replace TODO comments with NOTE where features are intentionally disabled
- Remove unused leadContextByTeam from TeamDetailView store selector
62 files changed across main process, renderer, shared types, and hooks.
All 1646 tests pass, typecheck clean, 0 lint errors.
- Increased PREFLIGHT_TIMEOUT_MS to 60 seconds for improved preflight checks.
- Updated PREFLIGHT_PING_PROMPT for clarity and added new arguments to PREFLIGHT_PING_ARGS for enhanced probing.
- Introduced isTransientProbeWarning function to better handle transient warnings during probe operations.
- Enhanced readiness messages in TeamProvisioningService to provide clearer feedback based on warning states.
- Improved ClaudeLogsSection to reflect team status more accurately in log messages.
- Simplified message sending behavior in SendMessageDialog and TaskCommentInput by removing modifier key references.
- Added subagent message preview functionality in MemberLogsTab for better task tracking and visibility.
- Added new properties to ProvisioningRun for managing lead text emission state and throttling.
- Implemented logic to push lead text messages immediately after provisioning, improving real-time updates in the UI.
- Updated DisplayItemList to support customizable render order for display items.
- Refactored task assignment visibility in various components to replace "Не назначено" with "Unassigned" for better clarity.
- Enhanced TaskDetailDialog and KanbanTaskCard to improve user experience with task ownership display.
- Implemented validation for member names to prevent the use of auto-suffixed names (e.g., "alice-2") in TeamDataService and TeamProvisioningService.
- Added cleanup functionality to remove auto-suffixed members from configuration and metadata, ensuring a cleaner team member list.
- Enhanced error handling for member name inputs, including checks for empty names and reserved names like "team-lead".
- Updated member management logic in TeamFSWorker to drop auto-suffixed members from the member map.
- Improved overall robustness of team member handling across services.
- Added functionality to drop CLI auto-suffixed duplicates (e.g., "alice-2") when the base name exists in TeamConfigReader, TeamMemberResolver, and TeamMembersMetaStore.
- Introduced createCliAutoSuffixNameGuard utility to manage name validation.
- Updated ActivityItem component to handle system messages with distinct styling.
- Enhanced CSS variables for system activity messages in index.css.
- Refactored SortableTab and TeamTabSectionNav components for improved layout and accessibility.
- Bumped package version from 0.1.0 to 1.0.0 to reflect significant updates.
- Added @codemirror/lint dependency to enhance code linting capabilities.
- Updated pnpm-lock.yaml to include the new linting dependency version.
- Added AGENT_BLOCK constants import to teams.ts for better organization.
- Cleared silentUserDmForward flag in TeamProvisioningService after successful and errored turns to ensure accurate state management.
- Updated TeamDataService to ensure consistent kanban task status updates with rollback capabilities on failure.
- Introduced silentUserDmForward functionality in TeamProvisioningService to manage internal DM forwarding to teammates without user echo.
- Enhanced task status update logic in TeamTaskWriter to prevent redundant updates.
- Improved ClaudeLogsSection to support search query overrides for better log filtering in the UI.
- Introduced caching mechanisms in TeamProvisioningService to optimize probe results and reduce redundant calls.
- Refactored warmup logic to utilize a new getCachedOrProbeResult method for better performance.
- Enhanced DisplayItemList, TextItem, and ThinkingItem components to support optional search query overrides for improved inline highlighting.
- Updated MarkdownViewer to handle search highlighting more effectively, accommodating local search queries.
- Improved TaskAttachments and TaskDetailDialog components with better handling of task assignment visibility and user experience.
- Introduced functions to identify and filter out internal coordination noise from inbox messages, improving notification relevance.
- Updated TeamProvisioningService to automatically mark noise messages as read, reducing clutter for team leads.
- Enhanced TeamDetailView and MessagesFilterPopover to allow users to toggle visibility of noise messages in the UI.
- Refactored various components to improve the handling of task attachments and message serialization, ensuring better user experience.
- Improved error handling and state management in session detail fetching, allowing for real-time updates without UI disruptions.
- Integrated yet-another-react-lightbox to improve image preview functionality across various components.
- Updated ImageLightbox and AttachmentDisplay to utilize the new lightbox for displaying images.
- Enhanced TaskAttachments and TaskCommentsSection to support image lightbox previews, improving user experience when viewing attachments.
- Refactored SendMessageDialog and EditorImagePreview to ensure consistent image handling with the new lightbox implementation.
- Introduced functionality for managing task attachments, including file storage and retrieval with size validation.
- Added methods for sanitizing filenames and detecting MIME types based on file headers.
- Enhanced TeamTaskAttachmentStore to support new attachment naming conventions and improved file path management.
- Updated TeamProvisioningService to include new commands for attaching files to tasks and comments.
- Improved UI components to facilitate attachment management, including confirmation dialogs for task deletions and enhanced log displays.
- Introduced TEAM_GET_CLAUDE_LOGS IPC channel for fetching buffered Claude CLI logs.
- Implemented handleGetClaudeLogs function to validate requests and retrieve logs with pagination support.
- Enhanced TeamProvisioningService to manage and store Claude log lines, including limits on stored logs.
- Added ClaudeLogsSection component to display logs in the UI, with support for pagination and real-time updates.
- Updated relevant types and API interfaces to accommodate new log retrieval features.
- Updated task sorting logic in TeamTaskReader to handle non-numeric IDs with stable lexicographic ordering.
- Refactored ActivityItem to remove unnecessary whitespace for cleaner code.
- Enhanced AttachmentPreviewItem to improve accessibility by adding pointer-events-none class for disabled state.
- Modified MessageComposer to ensure the summary remains compact during message sending.
- Added cleanup logic in useResizableColumns to handle global listeners and styles during drag events.
- Updated local image storage documentation to reflect changes in protocol handling for attachments.
- Added attachment metadata handling in message sending and inbox writing processes, improving attachment management.
- Implemented size validation for attachments in the TeamAttachmentStore, ensuring compliance with storage limits.
- Enhanced UI components to support attachment previews and improved user experience in managing attachments.
- Introduced a new RoleSelect component for better role management within teams.
- Added support for lead context usage tracking, allowing retrieval of context window usage for team leads.
- Implemented attachment handling in task comments, enabling users to add and manage attachments with size and type validation.
- Updated README to include new features related to visual workflow editor and multi-model support.
- Improved error handling and validation for task comments and attachments, ensuring a smoother user experience.
- Updated README to specify CLI runtime capabilities for headless environments.
- Introduced a comprehensive implementation plan for the diff view feature, detailing phases, required packages, types, IPC channels, backend services, and UI components.
- Added new documentation on competitors in AI orchestration platforms and research on local image storage and markdown rendering pipeline.
- Included a workflow editor research document to evaluate visual libraries for node-based workflow orchestration.
The app was reading OAuth tokens from ~/.claude/.credentials.json and
injecting them as CLAUDE_CODE_OAUTH_TOKEN into spawned CLI processes.
These tokens are almost always stale because Claude Code refreshes
tokens in-memory but rarely writes back to the credential store.
When CLAUDE_CODE_OAUTH_TOKEN is set in the environment, the CLI uses it
directly instead of going through its own auth/refresh flow, causing
every API call to fail with 401 "OAuth token has expired".
Remove all credential-file reading logic and let the CLI handle its own
authentication. ANTHROPIC_API_KEY and ANTHROPIC_AUTH_TOKEN (explicitly
set by user) are still passed through.
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
- Changed default value of includeSubagentErrors to false across multiple components for consistency in notification settings.
- Updated type definitions for statusChangeStatuses to use string arrays instead of TeamTaskStatus, enhancing flexibility in status management.
- Adjusted step numbering in TeamProvisioningService to improve clarity in task execution instructions.
- Enhanced logic in teamSlice to correctly handle status changes, including the new 'approved' kanban column, ensuring accurate notifications for task transitions.
- Adjusted step numbering in the launch prompt to ensure consistency and clarity in instructions for solo team task execution.
- Updated related instructions to reflect the new numbering, enhancing the overall readability of the process.
- Updated fileMentionsTaskId method to include an 'assumeTeam' parameter for better team detection in logs.
- Added logic to extract team information from process entries and message content, improving task attribution accuracy.
- Enhanced handling of task updates without explicit team names, ensuring correct task processing in solo scenarios.
- Improved overall robustness of log parsing and team identification, facilitating better task management in team environments.
- Updated task assignment notifications to skip inbox messages when leads assign tasks to themselves, improving user experience for solo teams.
- Refactored notification logic in TeamAgentToolsInstaller and TeamDataService to ensure clarity and maintainability.
- Introduced new functionality in GlobalTaskList to manage pinned and archived tasks, enhancing task visibility and organization.
- Added renaming capabilities for tasks in SidebarTaskItem, allowing users to edit task subjects directly.
- Improved overall task filtering and grouping logic to support better task management practices.
- Implemented deterministic interval scoping in ChangeExtractorService to improve task change retrieval when no specific scope is found.
- Added a new method, extractIntervalScopedChanges, to handle changes based on provided intervals, enhancing the accuracy of change tracking.
- Updated the logic for deriving intervals from task status history, ensuring better handling of task transitions.
- Refactored related code for improved clarity and maintainability, including better type definitions and error handling.
- Updated the `getTaskChanges` method to accept an optional `options` parameter, allowing for more granular control over the retrieval of task changes.
- Introduced new fields in the options object, including `owner`, `status`, `since`, and `intervals`, to improve filtering capabilities.
- Refactored related services and IPC methods to accommodate the new options, enhancing the overall task change management experience.
- Improved type definitions for better clarity and maintainability.
- Added new configuration options for task status change notifications, including toggles for enabling notifications, solo mode restrictions, and customizable target statuses.
- Updated validation logic to accommodate new notification settings, ensuring proper handling of boolean and array types.
- Enhanced UI components to allow users to manage status change notification preferences effectively.
- Implemented backend logic to detect and trigger notifications based on task status changes, improving user awareness of task progress.
- Introduced a new `statusHistory` feature to record every status transition of tasks, including the previous status, new status, timestamp, and actor responsible for the change.
- Updated task creation and status update methods to append transitions to the status history, ensuring a comprehensive audit trail.
- Enhanced UI components to display the status history, providing better visibility into task progress and changes over time.
- Refactored related services to support the new status history functionality, improving overall task management practices.
- Removed unnecessary member metadata retrieval in TeamDataService to simplify task handling and prevent self-notifications for lead-owned tasks.
- Updated lead owner validation to ensure consistent case handling.
- Introduced a new reference in ChangeReviewDialog to manage in-flight file operations, preventing duplicate actions during file rejection.
- Enhanced changeReviewSlice to return null for invalid states, improving error handling and state management.
Made-with: Cursor
- Added a new "Solo mode" feature in the README, allowing a single agent to manage tasks independently, improving token efficiency.
- Updated TeamMemberLogsFinder to include team name in task ID checks, preventing cross-team task collisions.
- Enhanced TeamProvisioningService with clearer task status protocols and execution discipline guidelines to improve task management practices.
- Introduced new callbacks in ChangeReviewDialog for accepting and rejecting new files, streamlining the review process.
- Updated changeReviewSlice to handle file rejection logic, ensuring accurate state management during reviews.
Made-with: Cursor
- Updated WorktreeGrouper to normalize project paths before resolving identities and branches, ensuring consistent behavior across platforms.
- Enhanced TeamDataService to improve lead name resolution and prevent self-notification for comments on lead-owned tasks in solo teams.
- Added new utility functions in TeamDataService for better lead name handling and solo team validation.
- Improved TeamMemberLogsFinder to exclude owner sessions when the owner is the team lead, refining log retrieval logic.
- Updated UI components to reflect changes in team member suggestions based on solo team status.
Made-with: Cursor
- Added validation to prevent the use of reserved names ("user" and "team-lead") for team members, ensuring clearer error messages during member addition.
- Updated IPC handlers to improve logging functionality, enhancing observability of team-related actions.
- Implemented normalization of file paths across various services to ensure consistent handling on different platforms.
- Enhanced UI components to provide better feedback on team member statuses and actions.
Made-with: Cursor
- Added background polling timer stop during service shutdown to prevent hanging.
- Enhanced IPC handlers by importing and utilizing renderer log handlers for better logging.
- Updated team-related services to handle member provisioning more robustly, including validation for empty member arrays.
- Implemented timeout handling for file system operations to improve reliability.
- Improved UI components to reflect solo team status and provide clearer feedback on member counts.
Made-with: Cursor
- Added support for a new worker in the team file system to list teams, improving performance and reliability in team management.
- Introduced event loop lag monitoring in various IPC handlers to track and log slow operations, enhancing observability.
- Implemented caching for CLI installation status to reduce redundant calls and improve responsiveness.
- Updated project and team data services to include total session counts, optimizing data handling and performance.
- Enhanced error handling and logging across multiple services to provide clearer insights into performance issues and failures.
Made-with: Cursor
- Introduced a new utility function `readFileUtf8WithTimeout` to handle file reading with a specified timeout, improving robustness against long read operations.
- Added size validation for various team-related files (e.g., config, inbox, processes) to prevent issues with oversized files.
- Updated multiple services (TeamConfigReader, TeamDataService, TeamInboxReader, TeamKanbanManager, TeamMembersMetaStore, TeamProvisioningService, TeamSentMessagesStore, TeamTaskReader) to utilize the new file reading method and enforce size limits.
- Enhanced error handling to gracefully manage read timeouts and invalid file states, improving overall system stability.
Made-with: Cursor
- Updated error handling in TeamAgentToolsInstaller to provide clearer guidance on available domains, improving user experience.
- Added an important note in TeamProvisioningService documentation regarding domain support, clarifying that "member" is not a valid domain.
- Adjusted EditTeamDialog component for consistent styling by removing unnecessary class properties.
Made-with: Cursor
- Removed outdated OAuth token warning logic from TeamProvisioningService to streamline authentication handling.
- Updated TeamProvisioningBanner to prevent auto-dismissal of "ready" state, allowing users to inspect logs after rapid provisioning cycles.
- Enhanced TaskCommentsSection UI by integrating MemberBadge for author display and improving comment styling for better visual clarity.
Made-with: Cursor
- Introduced functionality to notify users of new messages in sentMessages.json, improving user awareness of team communications.
- Enhanced configuration validation to include new notification settings: notifyOnLeadInbox, notifyOnUserInbox, and notifyOnClarifications, ensuring proper boolean handling.
- Updated TeamProvisioningService to persist sent messages, improving message tracking and reliability.
- Improved UI components to reflect changes in message handling and user feedback during provisioning processes.
Made-with: Cursor
- Updated file naming in release workflow to use consistent dot notation for better clarity.
- Enhanced RELEASE.md to reflect updated file names for download links.
- Added logic to filter out the "user" pseudo-member in TeamMemberResolver to prevent confusion in team configurations.
- Improved error handling in TeamProvisioningService to avoid caching authentication failures and ensure accurate readiness status.
- Introduced visual tone handling in ProvisioningProgressBlock for better user feedback on errors.
Made-with: Cursor
- Implemented parallel execution of version verification and initial ping attempts to reduce overall wait time during team provisioning.
- Enhanced error handling by prioritizing the version check for clearer error messages while maintaining the integrity of subsequent ping attempts.
- Streamlined the logic for retrying ping attempts, improving the efficiency of the preflight authentication process.
- Added a new handler for replacing team members, allowing bulk updates to team member roles and workflows.
- Enhanced the FileSearchService to include caching for file listings, improving performance by reducing redundant file system scans.
- Updated editor and team-related services to support the new member replacement feature, ensuring proper validation and error handling.
- Improved UI components to accommodate workflow input for team members, enhancing user experience during team management.
- Updated fallback home path logic to correctly handle 'root' user case in WSL.
- Refactored process renaming in TeamAgentToolsInstaller to include retry logic on Windows for better error handling during concurrent operations.
- Enhanced user information retrieval in TeamProvisioningService to handle potential errors gracefully.
- Clarified documentation in processKill utility regarding platform-specific behavior.
- Introduced a comprehensive FAQ section in the README to address common user queries regarding app installation, code handling, agent communication, and project management.
- Enhanced cross-platform keyboard shortcut handling in the Electron app for better user experience on macOS and Windows/Linux.
- Updated signal handling in the standalone process to ensure proper shutdown behavior across platforms.
- Improved WSL user resolution logic to support default user retrieval for better compatibility.
- Enhanced notification handling to support cross-platform features and improve user feedback.
- Refactored SSH connection management to include additional key file types and improve authentication handling.
- Updated team management services to ensure consistent process termination across platforms.
- Improved project path handling in team provisioning to accommodate different operating systems.
- Enhanced editor components to utilize shared utility functions for path management, improving code maintainability.
- Introduced a new IPC handler for listing project files, enabling file mentions independent of editor state.
- Enhanced the MentionableTextarea component to support file suggestions based on project path, improving user experience when mentioning files.
- Implemented a custom hook for loading and filtering project files as mention suggestions, optimizing performance with caching.
- Updated relevant components to integrate project path handling, ensuring seamless file mention functionality across dialogs and message composers.
- Improved EditorFileWatcher to debounce content change events, optimizing git status cache invalidation for rapid file saves.
- Updated ProjectScanner to derive project and display names from actual paths, enhancing reliability in project identification.
- Enhanced IPC methods for creating tasks and sending messages directly from the editor context menu, streamlining team collaboration.
- Refactored task relationship handling to ensure accurate linking of tasks based on user actions.
- Introduced animations for new chat messages and comments, improving user experience in chat history and task comments sections.
- Updated notification configuration to separate settings for lead and user inbox messages, improving user control over notifications.
- Enhanced the handling of inbox message notifications to respect individual inbox settings.
- Introduced new IPC methods for managing watched directories, allowing for more granular file monitoring.
- Improved task management by implementing work intervals for task status transitions, ensuring accurate tracking of task progress.
- Added validation for task creation and configuration, ensuring proper input handling for project paths and task properties.
- Introduced a grace period in EditorFileWatcher to ignore rapid 'change' events during startup, preventing performance issues in large repositories.
- Added a new IPC channel for setting watched file paths, optimizing file monitoring by focusing on currently open tabs.
- Updated the editor API to include the new setWatchedFiles method, enhancing performance by avoiding unnecessary project-wide file watching.
- Enhanced tests for EditorFileWatcher to validate the new startup behavior and ensure proper event handling.
- Introduced a new IPC handler for reading binary files as base64 for inline previews, enhancing the editor's capability to display images directly.
- Implemented a placeholder component for non-previewable binary files, providing users with file information and an option to open in the system viewer.
- Enhanced the EditorFileWatcher to ignore permission errors and adjusted debounce timing for better performance during file system events.
- Updated the ProjectFileService to include a method for reading binary previews with security checks and MIME type validation.
- Improved the EditorImagePreview component to handle loading states and display images with a checkerboard background for transparency.
- Refactored the EditorBinaryState component to utilize the new binary preview functionality, streamlining the display of binary files.
- Enhanced FileSearchService to implement parallel subdirectory traversal, improving efficiency in file collection.
- Refactored ProjectFileService to reuse directory stats, reducing unnecessary file system calls.
- Updated multiple components (EditorStatusBar, EditorTabBar, EditorToolbar, GitStatusBadge, QuickOpenDialog, SearchInFilesPanel) to utilize Zustand's shallow comparison for improved state management and performance.
- Introduced a module-level cache for QuickOpenDialog to minimize redundant API calls and enhance user experience.
- Added cache invalidation logic in editorSlice to ensure fresh data on file system changes.
- Introduced debouncing in EditorFileWatcher to aggregate rapid file system events, reducing unnecessary callbacks.
- Enhanced FileSearchService to parallelize file checks and improve efficiency in collecting file paths from directories.
- Updated EditorFileTree and ProjectEditorOverlay components to optimize state management and reduce re-renders using Zustand's shallow comparison.
- Added tests for EditorFileWatcher to ensure proper event handling and debouncing functionality.
- Enhanced FileSearchService to parallelize subdirectory traversal, improving performance when collecting file paths.
- Refactored ProjectFileService to classify directory entries without I/O, followed by parallel resolution of entries, optimizing file system access.
- Updated QuickOpenDialog to implement a search feature with a limit on rendered files, improving user experience when navigating large file sets.
- Introduced a new method for resolving symlinks in ProjectFileService, ensuring proper handling of symbolic links within the project structure.
- Added API endpoints for adding and removing custom project paths, allowing persistence across app restarts.
- Implemented IPC handlers for managing custom project paths in the application.
- Introduced functionality for adding and removing task relationships (blockedBy, blocks, related) between tasks, enhancing task management capabilities.
- Updated relevant components and services to support the new task relationship features and ensure proper integration with the existing task management system.
- Enhanced notifications for task relationships to improve user awareness of task dependencies.
- Added a retry mechanism for checking authentication status in the CliInstallerService to handle stale locks after Ctrl+C interruptions.
- Introduced constants for maximum retries and delay between attempts to improve robustness.
- Updated logging to provide detailed feedback on retry attempts and outcomes.
- Implemented functionality to read members from members.meta.json for both UI-created and CLI-created teams.
- Added error handling to ensure the listing process continues even if the meta file is broken.
- Added a new file renaming functionality in the editor, allowing users to rename files and directories in place.
- Introduced notification settings for team inbox messages and task clarifications, enabling users to receive native OS notifications for important updates.
- Updated the README to reflect the new features and provide a clearer overview of the task management capabilities.
- Improved the application icon handling for notifications across different platforms.
- Introduced CLAUDE_CODE_DIR constant for the .claude/worktrees/ directory.
- Updated GitIdentityResolver to recognize and handle worktrees from Claude Code CLI.
- Enhanced WorktreeBadge and DashboardView to display appropriate labels for Claude Code worktrees.
- Updated type definitions and source labels to include 'claude-code' for better integration.
- Improved session handling in DateGroupedSessions and FileSectionDiff components to accommodate new worktree type.
- normalizeForCompare and isPathWithinRoot now use path.resolve()
for consistent drive-letter handling on Windows
- Remove unused TOOL_VERSION constant (ESLint no-unused-vars)
- Fix isDir heuristic: use backend-provided isDirectory instead of
filename-based guessing (breaks for Makefile, .github, etc.)
- Add scroll-to-line on search result click via editorPendingGoToLine
- Add Cmd+Shift+W shortcut for toggling line wrap
- Rewrite Quick Open to fetch all project files from backend API
instead of flattening the loaded tree (limited to expanded dirs)
- Fix fd leak in atomicWrite: close file handle in finally block
- Add a11y: role=dialog/alert, aria-modal, aria-label on modals
- Add type=button on error state buttons
- Added a timeout mechanism to the getBranch calls in TeamDataService to prevent hangs on Windows setups, improving reliability during team data retrieval.
- Introduced performance logging in TeamDetailView and teamSlice to track the start and completion of team selection processes, enhancing debugging capabilities.
- Updated error handling to provide clearer warnings during team provisioning and selection, improving user experience.
- Added performance logging to the handleGetData function, tracking the duration of team data retrieval and logging warnings for slow responses.
- Implemented a timeout mechanism in the selectTeam function to prevent long-running fetch operations, improving user experience.
- Enhanced the getTeamData method with detailed timing metrics for each data loading step, allowing for better performance analysis and debugging.
- Introduced a caching mechanism for team display names to reduce redundant API calls and improve performance.
- Updated file change event handling to debounce cache invalidation, preventing unnecessary rescans during rapid file changes.
- Enhanced GlobalTaskDetailDialog and TaskDetailDialog to manage loading states and improve team data fetching logic.
- Refactored teamSlice to streamline team selection and data loading processes.
- Introduced constants for maximum session and project path history limits to optimize memory usage.
- Updated `TeamConfigReader` and `TeamProvisioningService` to limit session and project path history to defined maximums.
- Enhanced `TeamMembersMetaStore` to handle large meta files more efficiently by checking file size before processing.
- Refactored state management in `teamSlice` to include optimized lookups for team summaries by name and session ID.
- Introduced `mapLimit` function to manage concurrent processing of team directories, optimizing performance.
- Added `readFileHead` function to read the beginning of large configuration files efficiently.
- Implemented `extractQuotedString` to safely extract values from JSON strings in configuration headers.
- Enhanced error handling and validation for team configuration files, ensuring robust processing of team data.
- Updated logic to handle large configuration files differently, improving overall reliability and performance.
- Introduced `EditorErrorBoundary` component to catch runtime errors in CodeMirror, providing a fallback UI to prevent crashes.
- Updated file handling logic to utilize `isbinaryfile` for more reliable binary detection, replacing manual null-byte scans.
- Enhanced `openFile` method to prevent duplicate tabs for already opened files.
- Improved documentation for new components and updated file lists to reflect recent changes.
- Optimized file watcher and path validation processes for better performance and reliability.
- Replaced direct Git command usage with `simple-git` for more reliable status tracking, including support for renamed files and conflict detection.
- Updated IPC channels to reflect changes in Git status retrieval method.
- Enhanced file watcher initialization on Windows to prevent UV thread pool saturation by starting watchers sequentially.
- Improved application startup by staggering context system initialization and notification listeners to optimize performance.
- Implemented draft autosave functionality to prevent data loss during crashes, with recovery options for unsaved changes.
- Updated file management services to support better path validation and conflict detection.
- Enhanced performance with optimized file watcher and caching strategies for project scanning.
- Improved user experience with confirmation dialogs for unsaved changes and refined keyboard shortcuts.
- Documented testing strategies and rollback plans for iterative development.
- Introduced `EditorFileWatcher` for live file change detection and `GitStatusService` for displaying Git status in the file tree.
- Added context menu for file operations (create, delete) and implemented multi-tab support for the editor.
- Enhanced user experience with keyboard shortcuts, search functionality, and breadcrumb navigation.
- Updated IPC channels for file operations and integrated conflict detection during file saves.
- Improved performance with file watcher optimizations and virtualized file tree rendering.
- Added detailed architecture and component hierarchy documentation for the in-app project editor.
- Introduced `ProjectFileService` to manage file operations with improved path validation.
- Updated `electron.vite.config.ts` to set `UV_THREADPOOL_SIZE` for better performance on Windows.
- Deferred non-critical startup tasks in `index.ts` to avoid thread pool contention.
- Enhanced `CliInstallerService` with timeout handling for status gathering to prevent UI hangs.
- Added tests for `CliInstallerService` to ensure proper timeout behavior.
- Added architectural plan and iteration plan for the in-app project editor.
- Introduced new components for the editor, including CodeEditorOverlay, FileTreePanel, and EditorTabsPanel.
- Established state management using Zustand for editor state persistence.
- Implemented IPC channels for file operations and editor functionality.
- Enhanced TeamDetailView with a button to open the editor overlay.
- Conducted reuse analysis for existing components to optimize codebase integration.
- Updated CliInstallerService and TeamProvisioningService to use execCli and spawnCli for improved error handling and compatibility, particularly on Windows.
- Enhanced child process utility functions to better manage non-ASCII paths and provide consistent behavior across different platforms.
- Adjusted tests to mock new child process utilities and verify correct usage in service methods.
- Added a helper function to build the child process environment with the correct HOME directory, addressing issues with non-ASCII usernames on Windows.
- Updated CLI installer methods to utilize the new environment setup for improved compatibility and error handling.
- Updated the postinstall script in package.json to handle rebuild failures gracefully.
- Added clearContext option in team launch requests to allow starting fresh sessions without resuming previous context.
- Improved CLI installer logging by integrating raw output chunks for better terminal rendering.
- Refactored components to utilize TerminalLogPanel for displaying installation logs, enhancing user experience during CLI installation.
- Updated various services and hooks to support the new clearContext feature and raw logging.
On Windows, parallel writes to the same inbox file cause race conditions
where atomicWrite verification fails (another process overwrites between
write and verify). Added retry loop (8 attempts) matching the existing
pattern in addTaskComment. Bumps teamctl version to 6.
Fixes CI failure: test (windows-latest) "parallel messages to same inbox"
On Windows, parallel writes to the same inbox file cause race conditions
where atomicWrite verification fails (another process overwrites between
write and verify). Added retry loop (8 attempts) matching the existing
pattern in addTaskComment. Bumps teamctl version to 11.
Fixes CI failure: test (windows-latest) "parallel messages to same inbox"
- Updated the handling of bash lines to ensure unique file tracking by using a Set to eliminate duplicates.
- Added logic to attribute per-file line changes only when a single file is touched, enhancing accuracy in line addition and removal reporting.
- Wrapped terminal IPC handler functions (write, resize, kill) in try/catch blocks to log errors from node-pty, improving robustness against PTY failures.
- Updated the TeamAgentToolsInstaller to increment TOOL_VERSION to 10, reflecting changes in the tool's versioning.
- Refactored task comment handling in TeamAgentToolsInstaller to include retry logic for improved reliability during task updates.
- Consolidated role constants into a new teamRoles.ts file for better organization and reuse across components.
- Updated the root cause analysis for false negatives in diff matching, clarifying that context lines are discarded during matching.
- Improved the `structuredPatch()` method to merge hunks based on a new threshold, enhancing accuracy in matching snippets.
- Implemented reconstruction of "old side" and "new side" content from hunks, including context lines to prevent false negatives.
- Enhanced the `CliStatusBanner` component to improve user feedback on CLI authentication status.
- Updated the change review slice to incorporate file chunk counts for better hunk decision handling.
- Added PtyTerminalService to manage PTY terminal processes, enabling terminal functionalities within the application.
- Updated CLI installer to include authentication status checks, providing feedback on user login state.
- Enhanced the dashboard with a warning banner for CLI installation status, prompting users to log in if not authenticated.
- Introduced IPC channels for terminal operations, allowing communication between main and renderer processes for terminal management.
- Improved TaskCommentsSection and other components to support new features and enhance user experience during task management.
- Added detailed audit report for the diff view feature, covering line count reliability, hunk parsing, and UI rendering.
- Introduced fix plans addressing critical bugs, including cache TTL adjustments, memory safeguards for LCS, and unified line counting methods.
- Enhanced notification handling for team messages, integrating native OS notifications for improved user experience.
- Updated various components and services to support new features and optimizations, ensuring better performance and reliability in the diff viewing process.
- Incremented TOOL_VERSION to 9 for the CLI tool.
- Introduced setTaskOwner function to manage task ownership, allowing assignment and clearing of owners.
- Updated CLI commands to include task owner management options in help documentation.
- Enhanced Kanban components to support a compact view for task cards.
- Improved member color mapping to ensure unique colors for team members.
- Added asynchronous execution support in teamctl tests for better concurrency handling.
- Introduced the CliInstallerService to manage CLI installation, including status checks and installation processes.
- Added IPC handlers for CLI installer operations, enabling communication between main and renderer processes.
- Implemented the CliStatusBanner and CliStatusSection components to display CLI installation status and controls in the dashboard and settings.
- Enhanced the dashboard and settings UI to provide users with real-time feedback on CLI installation progress and errors.
- Updated the TeamDataService to support task clarification features, improving task management capabilities.
- Removed outdated pricing entries for Claude models from pricing.json to streamline configuration.
- Enhanced the getFileContent method in FileContentResolver to accept snippets for improved content diffing.
- Updated IPC methods to support new parameters for file content retrieval, improving data handling in the review process.
- Introduced accurate line addition and removal tracking in file diffs, enhancing the review experience.
- Improved UI components to reflect changes in file content handling, ensuring better user interaction during reviews.
- Updated the provisioning prompts in TeamProvisioningService to include project name alongside team and lead information, enhancing clarity for non-interactive CLI sessions.
- Refactored the RepositoryCard component in DashboardView to replace button with a div for improved accessibility and keyboard navigation, allowing users to open project paths more intuitively.
- Modified ChangeReviewDialog and ContinuousScrollView components to track discard actions using a record of counters per file, improving state management during file reviews.
- Implemented functionality for restoring soft-deleted teams and permanently deleting teams from the system.
- Introduced new IPC channels for team restoration and permanent deletion, enhancing team management capabilities.
- Updated TeamDataService and related components to handle the new operations, ensuring data integrity during team management.
- Enhanced UI components to support team restoration and deletion actions, improving user experience and management workflows.
- Added ReviewDecisionStore to manage loading, saving, and clearing review decisions from disk.
- Introduced new IPC channels for loading, saving, and clearing decisions, enhancing the review process.
- Updated ChangeReviewDialog and related components to integrate decision persistence, improving user experience during reviews.
- Implemented debounced saving of decisions to optimize performance and reduce unnecessary writes.
- Added functionality for soft-deleting tasks, allowing tasks to be marked as deleted without permanent removal.
- Introduced new IPC channels for soft-deleting tasks and retrieving deleted tasks, enhancing task management capabilities.
- Updated TeamDataService and TeamTaskWriter to handle soft delete operations and maintain task integrity.
- Enhanced the UI components to support viewing and managing deleted tasks, improving user experience and task visibility.
- Implemented a TrashDialog for displaying deleted tasks, allowing users to review and manage their deleted items effectively.
- Updated `ProcessesSection` to directly access data from Zustand store, eliminating prop drilling for cleaner component structure.
- Added new guidelines in `react.md` for accessing data from the store over props to streamline component communication.
- Enhanced `TeamProvisioningService` to include task snapshots for team members, improving task management and visibility.
- Implemented notifications for killed processes, providing better feedback to team leads about process management actions.
- Refactored `TaskDetailDialog` and `GlobalTaskDetailDialog` to improve header content handling, enhancing user experience.
- Introduced folder collapsing functionality in `ReviewFileTree`, allowing for better navigation and organization of file structures.
- Added process registration and health tracking capabilities in TeamDataService, allowing teams to monitor and manage background processes effectively.
- Introduced new CLI commands for registering, unregistering, and listing processes, enhancing the command-line tool's functionality.
- Implemented periodic health checks for registered processes, automatically updating their status and notifying the UI of changes.
- Enhanced the FileWatcher to emit team change events for process updates, ensuring real-time synchronization with the UI.
- Updated the team detail view to display active CLI processes, improving visibility into team operations.
- Added documentation for new process management protocols and CLI commands to assist users in managing background processes.
- Introduced a continuous scroll mode for the diff view, allowing users to review multiple files in a single scrollable container.
- Added lazy loading functionality to improve performance by loading file content as it approaches the viewport.
- Implemented a new portion collapse feature to allow users to expand unchanged regions incrementally, enhancing context retention during reviews.
- Updated navigation to support smooth scrolling between files and improved keyboard shortcuts for file navigation.
- Enhanced the review toolbar to manage actions across all files, including bulk accept/reject options.
- Added new hooks and components to support the continuous scroll and lazy loading features, ensuring a seamless user experience.
- Introduced new IPC channel for retrieving lead activity state (active, idle, offline) for teams.
- Implemented lead activity state management in TeamProvisioningService, allowing real-time updates.
- Enhanced team detail and list views to display lead activity status, improving user awareness of team dynamics.
- Updated member components to reflect lead activity, providing better context for team members' statuses.
- Added localStorage fallback for comment read state management, ensuring data persistence across sessions.
- Added support for inferring team lead names from configuration, improving message attribution in task communications.
- Introduced new dependencies for CodeMirror language support, enhancing the editing experience for various programming languages.
- Implemented scoped item IDs in the CLI logs view to prevent cross-group collisions, improving UI clarity.
- Enhanced sorting logic in the team list view to prioritize alive teams and match current project paths.
- Added lazy-check functionality for task changes in Kanban cards, optimizing performance and user experience.
- Updated diff view components to support new language features and improve overall editing capabilities.
- Added support for editing file content during reviews, allowing users to save changes directly to disk.
- Introduced new IPC channels for saving edited files and handling content updates.
- Enhanced the review toolbar with actions for saving and discarding edits, along with indicators for edited files.
- Implemented keyboard shortcuts for improved navigation and editing experience.
- Integrated a new component for rendering CLI logs in a rich format, replacing the previous raw JSON display.
- Updated state management to track edited contents and handle file edits effectively.
Brings in upstream changes:
- Session analysis reports (overview, cost, tokens, tools, git, quality)
- Unified cost calculation with LiteLLM pricing data
- Custom title bar for Linux with native toggle
- Auto-expand AI response groups setting
- MoreMenu toolbar component
- Various fixes (window drag, Ctrl+R, notification guard)
All merge conflicts resolved preserving both fork features (team management,
agent language, fullscreen, diff view) and upstream additions.
- Added 'fallback' confidence level to TaskChangeSet for Phase 3 Tier 4.
- Updated line counting logic in ChangeExtractorService to use `jsdiff.diffLines` for accurate added/removed line counts.
- Introduced new IPC handlers for agent and task changes, improving the review process.
- Enhanced error handling in review handlers with a local wrapReviewHandler function.
- Updated documentation to reflect changes in task scoping and content extraction methods.
- Improved local storage management for viewed files, ensuring compatibility with new formats.
- Added agent block usage policy to TeamProvisioningService for better message formatting control.
- Introduced a comprehensive implementation plan for the diff view feature, structured in four phases: MVP (read-only), accept/reject per hunk, per-task scoping, and enhanced features.
- Phase 1 includes a read-only diff view per agent, utilizing JSONL data to display file changes.
- Defined new types for file changes and review data, and established IPC channels for fetching member changes and reading file content.
- Developed backend services for extracting file changes and aggregating review data, alongside frontend components for displaying diffs and managing state.
- Subsequent phases will enhance the diff view with accept/reject functionality, task-specific change scoping, and improved user experience features.
- Added IPC channel for updating a team member's role, including validation for team and member names.
- Implemented `handleUpdateMemberRole` function to manage role changes and notify the team lead of updates.
- Updated `TeamDataService` to support role changes and ensure data consistency.
- Enhanced UI components to allow role editing and display loading states during updates.
- Integrated role update handling in the team management dialogs, improving user experience.
- Introduced support for updating the agent language in the configuration, including a new callback in `initializeConfigHandlers`.
- Enhanced `handleUpdateConfig` to trigger the new language update callback when the agent language changes.
- Updated validation logic to ensure the agent language is a non-empty string.
- Modified the `TeamConfigReader` and `TeamProvisioningService` to handle the new language setting, ensuring teams are notified of language changes.
- Adjusted various components to accommodate the new task start and cancellation features, improving task management in the Kanban board.
- Improved the message sending process in `handleSendMessage` by separating try blocks for stdin delivery and persistence, preventing fallback to inbox on stdin success.
- Added logging for persistence failures after stdin delivery to ensure better tracking of issues.
- Updated `TeamSentMessagesStore` to handle IO errors gracefully, preserving optional fields and preventing crashes.
- Enhanced `MessageComposer` to clear draft only after successful message send, improving user experience.
- Fix member status resolution: members without messages now show as
idle/active instead of unknown based on task ownership
- Notify running team lead via stdin when a new member is added so
the lead can spawn the teammate process
- Map unknown presence label to idle for better UX clarity
- Added `provisioningOutputParts` to `ProvisioningRun` for accumulating assistant text during the provisioning phase.
- Updated `updateProgress` and `emitLogsProgress` functions to include the new `assistantOutput` in the progress state.
- Enhanced `ProvisioningProgressBlock` to display live assistant output using `MarkdownViewer`.
- Modified `TeamProvisioningBanner` to pass the new `assistantOutput` prop for rendering in the UI.
- Add highlight.js as direct dependency (was transitive via rehype-highlight, missing type declarations in CI)
- Replace `app.getLocale()` with `Intl.DateTimeFormat().resolvedOptions().locale` to avoid importing electron in TeamProvisioningService (broke tests that don't mock electron)
- Introduced a comprehensive implementation plan for the diff view feature, structured in four phases: MVP (read-only), accept/reject per hunk, per-task scoping, and enhanced features.
- Phase 1 includes a read-only diff view per agent, utilizing JSONL data to display file changes.
- Defined new types for file changes and review data, and established IPC channels for fetching member changes and reading file content.
- Developed backend services for extracting file changes and aggregating review data, alongside frontend components for displaying diffs and managing state.
- Subsequent phases will enhance the diff view with accept/reject functionality, task-specific change scoping, and improved user experience features.
- Added IPC channel for updating a team member's role, including validation for team and member names.
- Implemented `handleUpdateMemberRole` function to manage role changes and notify the team lead of updates.
- Updated `TeamDataService` to support role changes and ensure data consistency.
- Enhanced UI components to allow role editing and display loading states during updates.
- Integrated role update handling in the team management dialogs, improving user experience.
- Introduced support for updating the agent language in the configuration, including a new callback in `initializeConfigHandlers`.
- Enhanced `handleUpdateConfig` to trigger the new language update callback when the agent language changes.
- Updated validation logic to ensure the agent language is a non-empty string.
- Modified the `TeamConfigReader` and `TeamProvisioningService` to handle the new language setting, ensuring teams are notified of language changes.
- Adjusted various components to accommodate the new task start and cancellation features, improving task management in the Kanban board.
- Improved the message sending process in `handleSendMessage` by separating try blocks for stdin delivery and persistence, preventing fallback to inbox on stdin success.
- Added logging for persistence failures after stdin delivery to ensure better tracking of issues.
- Updated `TeamSentMessagesStore` to handle IO errors gracefully, preserving optional fields and preventing crashes.
- Enhanced `MessageComposer` to clear draft only after successful message send, improving user experience.
- Fix member status resolution: members without messages now show as
idle/active instead of unknown based on task ownership
- Notify running team lead via stdin when a new member is added so
the lead can spawn the teammate process
- Map unknown presence label to idle for better UX clarity
- Added `provisioningOutputParts` to `ProvisioningRun` for accumulating assistant text during the provisioning phase.
- Updated `updateProgress` and `emitLogsProgress` functions to include the new `assistantOutput` in the progress state.
- Enhanced `ProvisioningProgressBlock` to display live assistant output using `MarkdownViewer`.
- Modified `TeamProvisioningBanner` to pass the new `assistantOutput` prop for rendering in the UI.
- Add highlight.js as direct dependency (was transitive via rehype-highlight, missing type declarations in CI)
- Replace `app.getLocale()` with `Intl.DateTimeFormat().resolvedOptions().locale` to avoid importing electron in TeamProvisioningService (broke tests that don't mock electron)
- Replaced local IPC channel constants in `index.ts` with imports from `@preload/constants/ipcChannels` for better consistency.
- Simplified the `leadRelayCapture` assignment in `TeamProvisioningService`.
- Updated markdown plugin imports across multiple components to use the new `REHYPE_PLUGINS` constant.
- Enhanced task status display logic in `TaskRow` for improved clarity.
- Adjusted CSS for better syntax highlighting in the editor.
- Updated `dev:kill` script to use a dedicated Node.js script for improved process termination.
- Enhanced `TeamProvisioningService` to trigger team refresh events for live lead replies, improving message handling.
- Refactored message deduplication logic in `handleGetData` to prevent duplicate messages from lead sessions and lead processes.
- Introduced `validateOpenPathUserSelected` function to allow user-selected paths while enforcing security checks.
- Improved UI components in `TeamListView` and `ActivityItem` for better user experience and accessibility.
- Added progress bar for task completion in `DashboardView`, enhancing task tracking visibility.
- Introduced `withInboxLock` function to manage concurrent access to inbox files, preventing race conditions during message processing.
- Refactored `TeamInboxWriter` and `TeamProvisioningService` to utilize the new locking mechanism, ensuring safe read/write operations on inbox files.
- Updated `TeamListView` and related components to improve user experience during team management and message handling.
- Added new dependencies for linting and formatting, enhancing code quality and maintainability.
- Added `stopTeam` method in `TeamProvisioningService` to terminate running processes for teams, improving resource management.
- Introduced IPC channel `TEAM_STOP` to handle stop requests from the renderer process.
- Enhanced message relaying for team leads by implementing `relayLeadInboxMessages`, ensuring timely communication of unread messages.
- Updated UI components to support stopping teams and display pending replies, enhancing user experience during team management.
- Updated `TeamMemberLogsFinder` to improve project directory resolution by falling back to `leadSessionId` if the encoded directory does not exist, enhancing reliability in locating project logs.
- Refactored `MemberLogsTab` to implement an initial loading state and auto-refresh functionality for ongoing tasks, improving user experience during log retrieval.
- Adjusted error handling and loading indicators to provide clearer feedback based on task status.
- Updated the getLogsForTask function to accept optional parameters for owner and status, allowing for more granular log retrieval based on task state.
- Modified the TeamMemberLogsFinder to include owner's session logs when the task is in progress, improving visibility into ongoing activities.
- Introduced new UI components for better task tracking, including ActiveTasksBlock and ProvisioningProgressBlock, enhancing user experience during team provisioning.
- Refactored related components to support the new functionality, ensuring seamless integration across the application.
- Added functionality in TeamDataService to automatically create comments from task-related inbox messages, enhancing task management.
- Introduced syncLinkedComments method to process messages and link them to corresponding tasks, ensuring relevant discussions are captured.
- Updated TeamTaskWriter to support deduplication of comments based on ID, preventing duplicate entries.
- Enhanced ActivityItem and ActivityTimeline components to improve recipient color handling for better visual feedback.
These changes aim to streamline communication around tasks and improve overall user experience in task tracking.
- Add TEAM_GET_LOGS_FOR_TASK to ipcChannels mock in teams.test.ts
- Add handler registration/removal assertions for the new channel
- Remove unused knownMembers destructuring in TeamMemberLogsFinder
- Introduced TEAM_GET_LOGS_FOR_TASK IPC channel to retrieve session logs related to specific tasks.
- Implemented handleGetLogsForTask function to validate inputs and fetch logs for a given task.
- Updated TeamMemberLogsFinder to include findLogsForTask method for session log retrieval based on task ID.
- Enhanced UI components to support displaying logs for tasks, improving task management and visibility.
- Updated related services and components to accommodate the new logging functionality.
These changes aim to enhance task tracking and improve collaboration within teams by providing access to relevant session logs.
- Add toggle in settings to auto-expand AI response groups
- Auto-expand new AI groups on live session refresh
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
- Implemented line counting for NotebookEdit and Bash commands in MemberStatsComputer to improve task tracking accuracy.
- Updated TeamDataService to include kanban column information for tasks, enhancing task visibility.
- Refactored Sidebar and GlobalTaskList components to support task filtering by status and team, improving user interaction.
- Introduced TaskFiltersPopover for better task filtering options, allowing users to filter tasks by status and unread comments.
- Enhanced UI components for better responsiveness and user experience in task management.
These changes aim to improve task management efficiency and enhance collaboration within teams.
- Updated the TeamAgentToolsInstaller to version 5, introducing a new command for adding comments to tasks.
- Implemented the addTaskComment function to handle comment creation, including validation and notification to task owners.
- Enhanced the TeamDataService to support fetching tasks alongside tool installation.
- Updated UI components to display unread comment counts and improve user interaction with task comments.
- Refactored various components to integrate task comments seamlessly into the existing workflow.
These changes aim to improve collaboration and communication within teams by facilitating task-related discussions.
- Added a new Contributor License Agreement (CLA) document to clarify contribution terms.
- Updated the license from MIT to GNU Affero General Public License v3.0 (AGPL-3.0).
- Introduced task comments feature, allowing users to add comments to tasks with validation for input length and content.
- Enhanced the TeamDataService to handle adding comments and sending notifications to task owners.
- Updated UI components to display comments and allow users to submit comments via a text area.
- Integrated task comments into the task detail dialog for better user interaction.
These changes aim to improve task management and enhance collaboration within teams.
- teams.ts: add type validation in handleCreateConfig for displayName/description/color
- CreateTaskDialog: scope draft keys per team to prevent cross-team leakage
- agentBlocks.ts: replace stateful singleton regex with factory function
- teams.test.ts: add missing channel assertions and use os.tmpdir()
- SendMessageDialog: move setState out of useEffect to render phase
- TeamMemberLogsFinder: remove unused projectId destructuring
- MentionableTextarea: add eslint-disable description
- useMentionDetection: replace deprecated wordWrap with overflowWrap
- Added validation for team configuration updates to ensure name, description, and color are strings.
- Improved member detection logic to avoid false positives by ensuring only one known member name is matched.
- Refactored post-launch configuration updates to combine session history and project path updates, preventing race conditions.
- Updated UI components to streamline state management for collapsible sections.
These changes aim to improve data integrity and user experience in team management functionalities.
- Introduced TEAM_START_TASK IPC channel to facilitate starting tasks and notifying agents.
- Updated task creation to include an option for immediate start, enhancing user experience.
- Enhanced task notifications with detailed instructions for agents upon task assignment.
- Improved team member logs handling and metadata extraction for better task tracking.
These changes aim to streamline task management and improve team collaboration efficiency.
- Added member color assignment using a new utility function for better visual representation in the UI.
- Updated team member prompts to encourage brief introductions, aligning with project guidelines.
- Introduced a draft persistence mechanism for message and task creation dialogs to enhance user experience.
- Refactored team configuration handling to support new member structures and improve data integrity.
This update aims to streamline team interactions and improve the overall user experience in team management features.
Two performance regressions introduced in recent PRs:
1. readAgentConfigs blocked transcript rendering (PR #50)
The agent config IPC call was awaited on the critical path of
fetchSessionDetail, preventing any transcript data from rendering
until the filesystem read completed. On macOS this was especially
noticeable due to security checks on first directory access.
Fixed by making the call fire-and-forget: the transcript renders
immediately and subagent color badges update asynchronously.
Also set the project cache key optimistically before the async call
to prevent duplicate in-flight requests on rapid navigation.
2. SessionSearcher stat()-called every session file on each search (PR #53)
LocalFileSystemProvider.readdir() did not populate the optional
mtimeMs field on FsDirent entries. The new SearchTextCache-based
SessionSearcher fell back to an individual fsProvider.stat() call
per session file when mtimeMs was missing, adding N extra filesystem
round-trips on every search in local mode.
Fixed by statting all entries concurrently inside readdir(), so
mtimeMs is always populated and the stat fallback is never triggered.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
- Added SearchTextCache for LRU caching of extracted search text with mtime invalidation.
- Introduced SearchTextExtractor for lightweight extraction of searchable text from session messages.
- Updated SessionSearcher to utilize the new extractor and cache for improved search performance.
- Added tests for SearchTextCache and SearchTextExtractor to ensure functionality and correctness.
Subagent badges now show distinct colors instead of generic gray.
Colors are resolved from the project's .claude/agents/*.md frontmatter
(color field), with deterministic hash-based fallback for unconfigured types.
New AgentConfigReader service reads agent definitions via IPC, cached
per project root to avoid redundant disk reads on session refreshes.
Team member colors remain unaffected (team branch has priority).
- Updated the default notification triggers to set 'enabled' to false for the .env File Access Alert, Tool Result Error, and High Token Usage triggers, allowing for more controlled notification management.
Sessions without the cwd field (older JSONL format) were creating a
separate subproject group, even when all sessions with cwd shared the
same value. The orphan subproject got a relative fallback path that
failed git identity resolution, causing zero sessions to load on select.
Now only counts distinct real cwds when deciding whether to split,
treating cwd-less sessions as belonging to the same project.
- Introduced TeamDataService for managing team-related data.
- Updated IPC handlers to include team management functionalities.
- Added new API channels for team listing and integrated them into the UI.
- Enhanced the renderer components to support team views and interactions.
- Implemented utility functions for team directory path management.
- Updated knip.json to exclude unused Remotion paths and dependencies.
- Cleaned up pnpm-lock.yaml by removing obsolete Remotion packages.
- Refactored TypeScript function signatures in main files for improved clarity.
- Enhanced various components for better code readability and maintainability.
- Removed obsolete Remotion preview and render scripts from package.json.
- Updated HttpServer to enhance static file serving logic, ensuring proper handling of renderer paths in both development and production modes.
- Added support for asarUnpack in package.json to facilitate unpacking of renderer files.
- Introduced a new Docker setup for running claude-devtools in standalone mode without Electron.
- Added Dockerfile and docker-compose.yml for easy deployment.
- Implemented .dockerignore to exclude unnecessary files from the Docker context.
- Updated package.json with new scripts for building and running the standalone server.
- Enhanced README with Docker usage instructions and environment variable configurations.
- Modified HttpServer to support serving static files and API in standalone mode.
- Updated various components to ensure compatibility with standalone operation.
- Added handlers for hiding and unhiding individual and multiple sessions in the configuration.
- Updated the ConfigManager to manage hidden sessions, including methods for bulk operations.
- Enhanced the IPC channels and preload scripts to support new session visibility features.
- Integrated UI components to allow users to toggle session visibility in the sidebar and context menus.
- Updated state management to reflect hidden sessions and support multi-select actions for bulk hiding/unhiding.
- Added context consumption tracking, including total context consumed and compaction events, to the session metadata.
- Introduced a new `PhaseTokenBreakdown` interface for detailed per-phase token contributions.
- Updated the `SessionContextPanel` to support a ranked view of context injections, allowing users to toggle between category and ranked displays.
- Implemented a `ConsumptionBadge` in the `SessionItem` component to show context consumption with a hover popover for phase breakdown details.
- Enhanced session sorting options in the sidebar to allow sorting by context consumption.
- Introduced functionality to select and manage the local Claude root folder, allowing users to specify a custom path.
- Added IPC handlers for selecting the Claude root folder and retrieving its information.
- Enhanced configuration validation to ensure the specified Claude root path is an absolute path.
- Updated the ServiceContext to reconfigure based on changes to the Claude root path, improving context management.
- Refactored related components to support the new Claude root path features, including updates to the UI and state management.
- Modified the author field in package.json to include an email address for better attribution.
- Improved error handling in SshConnectionManager by providing a clearer exit code message when remote command execution fails.
- Introduced new distribution scripts for macOS targeting ARM64 and x64 architectures.
- Updated README to clarify download instructions for macOS Apple Silicon and Intel users.
- Enhanced CI workflow to support building for both architectures, improving release process.
- Updated the ProjectScanner class to utilize a new asynchronous method for resolving file details, improving accuracy in file metadata retrieval.
- Introduced birthtimeMs to session file information, ensuring comprehensive metadata is available for session management.
- Adjusted session creation logic to account for the new birthtimeMs, enhancing the integrity of session timestamps.
- Improved the handling of auto-scroll behavior in ChatHistory and useAutoScrollBottom hook, allowing for smoother user experience during content updates.
This commit enhances the ProjectScanner's efficiency and improves user experience in chat history management.
- Updated the ProjectScanner class to use an asynchronous method for retrieving session filters, ensuring up-to-date session data.
- Introduced a new private method, getSessionFilterForProject, which refreshes composite IDs from disk in local mode to prevent stale entries.
- Enhanced notification listeners to clear existing timers for session and project refreshes, improving performance during rapid file changes.
- Implemented a mechanism to track refresh generations for sessions and projects, preventing stale overwrites during concurrent updates.
This commit improves the accuracy and efficiency of session and project data handling in the application.
- Added a WindowsTitleBar component to provide a conventional title bar experience when the native frame is hidden.
- Integrated window control functionalities (minimize, maximize, close) using IPC handlers for better user interaction.
- Updated the TabbedLayout to include the new WindowsTitleBar, ensuring a consistent UI across platforms.
- Enhanced the README with additional details about the new window controls feature.
This commit improves the user interface on Windows by providing familiar window management controls, enhancing usability and consistency.
- Revised the introductory text to better reflect the application's purpose.
- Added installation instructions for macOS and Windows, detailing download options and setup steps.
- Enhanced the visual presentation with additional badges and download buttons for improved user experience.
- Updated the development section to clarify prerequisites and build instructions.
This commit improves the README by providing clearer guidance for users and enhancing the overall presentation of the project.
- Added a step in the GitHub Actions workflow to set the package version based on the Git tag during the release process.
- This enhancement ensures that the version in package.json reflects the tagged release, improving version management and consistency.
This commit streamlines the release process by automating version updates from Git tags.
- Updated the README to reflect new features in Claude Code, including the ability to spawn subagents via the Task tool and coordinate teams with improved visibility.
- Added details on the rendering of subagent sessions as expandable inline cards, including execution traces, metrics, and tool calls.
- Enhanced description of teammate messages, highlighting color-coded cards and team lifecycle visibility.
- Clarified session summary metrics to differentiate between teammate and subagent counts for better user insights.
This commit significantly improves the documentation of team and subagent visualization features, providing users with a clearer understanding of the capabilities and enhancements in the application.
- Added new scripts for rendering and previewing videos using Remotion, enhancing multimedia capabilities.
- Updated package.json to include Remotion dependencies and commands for rendering videos in different formats.
- Modified .gitignore to exclude Remotion output files, ensuring a cleaner repository.
- Enhanced README to reflect new features and usage instructions for video rendering.
This commit significantly improves the application's multimedia functionality by integrating Remotion, allowing users to create and preview videos seamlessly.
- Updated the session retrieval API to include an optional `SessionsByIdsOptions` parameter, allowing clients to specify the desired metadata depth (light or deep) when fetching sessions by IDs.
- Modified the `ProjectScanner` and related services to support this new option, improving flexibility in session data retrieval.
- Enhanced the HTTP client and renderer components to accommodate the new options, ensuring consistent behavior across the application.
This commit improves session management by providing users with more control over the metadata returned, optimizing performance for various use cases.
- Added a new `metadataLevel` option to the sessions pagination API, allowing clients to specify the depth of metadata returned (light or deep).
- Updated the `ProjectScanner` to handle session metadata based on the specified level, improving performance and flexibility in session data retrieval.
- Enhanced the HTTP client and session slice to support the new metadata level option, ensuring consistent behavior across the application.
This commit enhances session management by providing users with the ability to choose the level of detail in session metadata, optimizing performance for different use cases.
- Implemented a new HTTP endpoint and IPC handler for retrieving session metadata based on an array of session IDs, allowing for the loading of pinned sessions that may not be included in paginated results.
- Enhanced session management by validating session IDs and capping the number of IDs processed to improve performance and reliability.
- Updated the renderer and store to handle the new functionality, ensuring that pinned sessions are preserved and loaded correctly.
This commit enhances the application's session handling capabilities, providing users with better access to their pinned sessions.
- Added support for remote todos path in SSH handlers, improving project organization.
- Updated ProjectPathResolver to utilize the filesystem provider for extracting current working directory.
- Optimized ProjectScanner to handle session file processing in batches, enhancing performance over SSH.
- Implemented noise filtering logic in WorktreeGrouper and FileWatcher to improve session management.
- Enhanced SshFileSystemProvider with retry logic for file operations, increasing reliability during transient errors.
This commit significantly improves the handling of SSH projects and enhances overall performance and reliability in file operations.
- Added a new `WorkspaceIndicator` component to display the active workspace and connection status.
- Integrated the `WorkspaceIndicator` into the `TabbedLayout` for improved workspace switching visibility.
- Removed the previous `ContextSwitcher` from `SidebarHeader` to streamline the UI.
- Updated `ServiceContext` and `ServiceContextRegistry` for better type handling and imports.
This commit enhances the user experience by providing a dedicated workspace indicator, facilitating easier context switching.
- Introduced an HTTP server to facilitate communication with the application.
- Added route handlers for managing application configuration, including getting and updating settings.
- Implemented notification operations with routes for retrieving, marking, and deleting notifications.
- Created project and session management routes to list projects, sessions, and their details.
- Developed SSH connection management routes for connecting, disconnecting, and retrieving SSH state and configuration.
- Enhanced the application architecture to support real-time event streaming via Server-Sent Events (SSE).
This commit significantly expands the application's capabilities by integrating an HTTP server and various management routes, improving user interaction and functionality.
- Add SSH connection profile management methods to ConfigManager
- addSshProfile(): Store connection profiles for quick reconnection
- removeSshProfile(): Remove profiles by ID
- updateSshProfile(): Update existing profiles
- getSshProfiles(): Retrieve all profiles
- setLastActiveContextId(): Persist last active context for app restart
- profiles array and lastActiveContextId field in ssh config section
- Context API already existed from plan 02-02 with all required IPC handlers and preload bridge
FileWatcher.dispose():
- Calls stop() to close watchers
- Clears all timers: retry, debounce, catch-up, polling
- Clears all tracking maps: lastProcessedLineCount, lastProcessedSize, activeSessionFiles, polledFileSizes, processingInProgress, pendingReprocess
- Calls removeAllListeners() LAST to prevent events during cleanup
- Sets disposed flag to prevent reuse
DataCache.dispose():
- Clears cache Map
- Disables caching
- Sets disposed flag to prevent reuse
- Auto-cleanup interval managed by caller (ServiceContext)
Both services prevent restart after disposal for proper lifecycle management.
- ServiceContext: service bundle for single workspace context
- Encapsulates all session-data services (ProjectScanner, SessionParser, SubagentResolver, ChunkBuilder, DataCache, FileWatcher)
- Manages service lifecycle (start, stop, dispose)
- Proper dependency chain wiring
- ServiceContextRegistry: coordinator for all contexts
- Manages Map of contexts with active tracking
- Enforces local context permanence (cannot be destroyed)
- Context switching (stops old watcher, starts new watcher)
- Safe disposal of SSH contexts
- Updated barrel exports in infrastructure/index.ts
- Remove dynamic fs/promises, os, and path imports from SubagentDetailBuilder
- Add fsProvider and projectsDir parameters to buildSubagentDetail function
- Replace fs.access() with fsProvider.exists() for file existence check
- Replace os.homedir() path construction with projectsDir parameter
- Update ChunkBuilder.buildSubagentDetail() to accept and pass new parameters
- Update IPC subagents handler to obtain provider and projectsDir from ProjectScanner
- Update initializeSubagentHandlers to accept ProjectScanner parameter
- Update handlers.ts to pass ProjectScanner to subagent handler initialization
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
- Add getFileSystemProvider() getter to ProjectScanner
- Update SessionParser.parseSessionFile() to pass provider to parseJsonlFile()
- Update SessionParser.parseSubagentFile() to pass provider to parseJsonlFile()
- Update SubagentResolver.parseSubagentFile() to pass provider to parseJsonlFile()
- Update SessionParser test mock to include getFileSystemProvider method
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
- Added functionality to save and retrieve the last SSH connection configuration, allowing for auto-fill on subsequent launches.
- Introduced new IPC channels for saving and getting the last SSH connection details.
- Updated the connection state management to persist the last connection information upon successful connection.
- Enhanced the ConnectionSection component to load the last connection details on mount and pre-fill the form fields.
- Refactored relevant types and state management to accommodate the new SSH last connection features.
- Removed the 'toolName' and 'matchField' properties from the default trigger configuration.
- Updated the default match field options to include a new option for matching against the entire JSON-serialized input.
- Added SSH config host alias support, allowing users to fetch and resolve host entries from the SSH config file.
- Introduced SshConfigParser to handle parsing of ~/.ssh/config and retrieving host aliases.
- Updated ConnectionSection to include a combobox for selecting SSH config hosts with auto-fill capabilities.
- Enhanced SshConnectionManager to utilize the new SshConfigParser for resolving host configurations.
- Added IPC channels for fetching SSH config hosts and resolving host aliases.
- Updated relevant types and state management to accommodate new SSH config features.
- Integrated electron-updater for automatic updates, including IPC handlers for checking, downloading, and installing updates.
- Updated electron-builder configuration to include entitlements and notarization scripts for macOS.
- Enhanced README with installation instructions and updated features.
- Added new components for update notifications and dialogs in the renderer.
- Improved CI workflow permissions for better release management.
