3d2a04e776
* feat(orchestrator): reuse existing same-profile session on workflow step switch
When a workflow step transition needs a different agent profile, look up
an existing session on the same task that already uses the target profile
and promote it back to primary instead of creating a fresh one. Reuses
COMPLETED and FAILED sessions (CANCELLED stays excluded — explicit user
stops shouldn't be auto-revived).
Backend (event_handlers_workflow.go):
- findReusableSessionForProfile: most recently updated session matching
the target profile, skipping CANCELLED.
- reuseSessionForStep: promotes the session to primary; if terminal,
revives via reviveReusedSession.
- reviveReusedSession: distinguishes "previously launched" (has
executors_running record -> flip to WAITING_FOR_INPUT, lazy-resume via
ResumeSession with stored token) from "never launched" (no record ->
flip to CREATED so autoStartStepPrompt routes through
StartCreatedSession for a full fresh launch). Clears stale
ErrorMessage/CompletedAt so the UI stops surfacing prior failures.
- createNewSessionForStep + completeAndStopSession: shared helpers.
Backend (task_operations.go):
- StartCreatedSession no longer calls processOnTurnStartViaEngine.
User-initiated messages already fire on_turn_start in
dispatchPromptAsync. Workflow-driven auto-start prompts arrived
because the workflow just transitioned us into this step via
on_turn_complete; firing on_turn_start again cascades the workflow
back out and the redirect-to-active-session logic delivers the prompt
to the wrong session's agent.
Frontend (web):
- task.updated handler follows focus to the new primary when the user
is viewing the task and was sitting on the previous primary.
- pinnedSessionId tracks user-initiated session selection
(setActiveSession sets it; setActiveSessionAuto leaves it alone).
The terminal-handoff branch in maybeAdoptSessionOnTransition skips
replacement when the terminating session matches the pin, so manually
clicking a session no longer yanks focus back to the workflow primary
each time the pinned session terminates.
Tests:
- TestSwitchSessionForStep_ReusesExistingProfileSession (never-launched).
- TestSwitchSessionForStep_ReusesPreviouslyLaunchedSession (launched).
- TestSwitchSessionForStep_ReusesFailedSession (FAILED reuse + cleanup).
- tasks.test.ts: focus-follow behavior across 4 scenarios.
- agent-session.test.ts: pinnedSessionId guard plus migration to
setActiveSessionAuto for WS-driven adoption.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(orchestrator): deferred task move with hand-off prompt + boot/turn-end event split
Adds move_task_kandev MCP tool that lets a workflow agent (e.g. QA at "Review")
move a task to another step with a prompt for the receiving agent. The move is
queued as a PendingMove and applied on the calling agent's turn-end so on_enter
processing doesn't race the still-running turn.
Also splits agent.ready into agent.boot_ready + agent.ready at the lifecycle
layer. Previously both signals shared one event and the orchestrator
disambiguated them via a resumeInProgressSessions flag — which had a race
when the boot signal arrived before persistResumeState wrote state=STARTING,
causing the boot to fire on_turn_complete against the just-revived step and
ping-pong the task forward through the workflow.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix: address PR #743 review feedback (Greptile + CodeRabbit)
Backend:
- isTransientPromptError no longer treats ErrExecutionNotFound as transient,
preventing executeQueuedMessage from infinite-requeueing on permanent
missing-execution errors. autoStartStepPrompt's explicit errors.Is check
before the transient branch keeps the recovery path working (Greptile P2 #1)
- applyPendingMove drains the orphaned hand-off prompt on ApplyTransition
failure so it can't be misdelivered to the source step on a future turn
(Greptile P2 #2)
- handleMoveTask returns errors instead of panicking when messageQueue is
nil; queueMoveTaskPrompt returns an error so the deferred path fails fast
if the queue can't accept the prompt (CodeRabbit CR-2)
- handleMoveTask rejects when no primary session exists and a hand-off prompt
is required, instead of silently dropping it (CodeRabbit CR-3)
- autoStartStepPrompt preserves attachments from queued messages (was: silently
dropped); attachment-only messages are no longer skipped; the fallback path
also forwards attachments (CodeRabbit CR-5)
- applyPendingMove reinserts the pending move on early failure paths (config
missing, task/step load errors) so a future turn-end retries naturally
(CodeRabbit CR-6)
- registerKanbanTools split into 3 helpers (list/profile/task) to satisfy
backend function-size lint limits (CodeRabbit CR-1)
Web:
- maybeAdoptSessionOnTransition's auto-adopt path also checks pinnedSessionId
to handle the reverse-event-ordering race (old COMPLETED arrives before new
STARTING) — pinned sessions are no longer yanked off the user. Regression
test added (CodeRabbit CR-7)
Tests:
- mockAgentManager records (executionID, prompt) pairs; new helper
capturedPromptsForExecution actually filters by exec ID instead of
returning all captured prompts (CodeRabbit CR-4)
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(web): respect pinned session in primary-follow-focus path
When the user clicks a session, setActiveSession sets pinnedSessionId. If a
workflow profile switch then updates the task's primarySessionId while the
user happens to still be on the previous primary, the focus-follow block in
tasks.ts was calling setActiveSessionAuto(taskId, newPrimary) and silently
overriding the explicit pin. Add pinnedSessionId !== previousPrimary as a
fifth condition. Regression test in tasks.test.ts covers exactly this
sequence.
Addresses Greptile P1 on PR #743.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix: address CodeRabbit review on PR #743 (3 new comments)
- handleMoveTask idle path now rolls back the queued hand-off prompt when
taskSvc.MoveTask fails, so a "you were moved..." message can't be delivered
on a future turn for a transition that didn't actually happen. Added
TakeQueued to the MessageQueuer interface to support this.
- lookupSession now returns (*models.TaskSession, error) so callers can
distinguish a backend lookup failure from a legitimate "no primary session"
state. handleMoveTask maps the error case to ErrorCodeInternalError instead
of collapsing it into ErrorCodeValidation.
- queueMoveTaskPrompt returns errors instead of log-and-continue (signature
change already shipped); existing tests updated to reflect the new contract.
- Refactored TestPendingMove_ReviewToInProgress_OneTransitionOnly: the
~280-line monolithic test is now split into a pendingMoveScenario builder
+ assertion helpers, each well under the 80-line / 50-statement lint limit.
All 14 review threads resolved.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix: relax move_task_kandev prompt requirement; fix CI lint
CI surfaced two issues after rebasing onto main:
- nestif lint warning on autoStartStepPrompt's queued-message merge block.
Extracted the take-and-merge logic into takeAndMergeHandoffMessage helper,
flattening the nested conditionals.
- E2E test settings/config-management 'agent can move a task to a different
step' failed because my CR-3 fix made the move_task_kandev prompt parameter
required. That broke admin/config-mode moves where there's no agent to
hand off to. Made prompt optional: when supplied AND the source session
is mid-turn, the deferred-move flow runs (queue prompt + record
PendingMove); otherwise just move the task. Refactored handleMoveTask
into deferMoveTaskWithPrompt and applyMoveTaskImmediate to keep each
function under the 80-line lint limit.
Tool descriptions in mcp/server/server.go and mcp/server/config_handlers.go
updated to reflect prompt's now-optional status. moveTaskHandler in
config_handlers.go forwards prompt only when set.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(mcp): treat 'no primary session' as a not-found, not an internal error
GetPrimarySessionByTaskID returns a plain error string ("no primary session
found for task: <id>") when the repo has no rows. My CR-B refactor was
treating ALL lookup errors as ErrorCodeInternalError, which broke the E2E
test 'agent can move a task to a different step' (config-mode move on a
freshly-created task that has no agent yet).
Match the not-found message and return (nil, nil); only real backend
failures bubble up as InternalError. Distinguishing properly with
errors.Is would require an exported sentinel that doesn't exist; matching
the noRowsErr substring is the pragmatic fix.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---------
Co-authored-by: Kandev Agent <agent@kandev.dev>
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
199 lines
5.9 KiB
Go
199 lines
5.9 KiB
Go
package messagequeue
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/kandev/kandev/internal/common/logger"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
// Service manages queued messages for sessions.
|
|
// Uses in-memory storage as queued messages are best-effort and transient.
|
|
type Service struct {
|
|
// In-memory storage: sessionID -> QueuedMessage
|
|
queued map[string]*QueuedMessage
|
|
// In-memory storage: sessionID -> PendingMove (deferred move_task_kandev moves)
|
|
pendingMoves map[string]*PendingMove
|
|
mu sync.RWMutex
|
|
logger *logger.Logger
|
|
}
|
|
|
|
// NewService creates a new message queue service
|
|
func NewService(log *logger.Logger) *Service {
|
|
return &Service{
|
|
queued: make(map[string]*QueuedMessage),
|
|
pendingMoves: make(map[string]*PendingMove),
|
|
logger: log.WithFields(zap.String("component", "message-queue")),
|
|
}
|
|
}
|
|
|
|
// TransferSession moves any queued message and pending move from one session
|
|
// to another. Used by workflow session switches (when a target step has a
|
|
// different agent profile and switchSessionForStep creates a new session) so
|
|
// a prompt queued by move_task_kandev on the old session reaches the new one.
|
|
// Existing entries on the destination session are preserved if no source entry
|
|
// is present; otherwise the source entry replaces the destination entry.
|
|
func (s *Service) TransferSession(ctx context.Context, oldSessionID, newSessionID string) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
if msg, ok := s.queued[oldSessionID]; ok {
|
|
msg.SessionID = newSessionID
|
|
s.queued[newSessionID] = msg
|
|
delete(s.queued, oldSessionID)
|
|
s.logger.Info("transferred queued message between sessions",
|
|
zap.String("from_session_id", oldSessionID),
|
|
zap.String("to_session_id", newSessionID),
|
|
zap.String("queue_id", msg.ID))
|
|
}
|
|
|
|
if move, ok := s.pendingMoves[oldSessionID]; ok {
|
|
s.pendingMoves[newSessionID] = move
|
|
delete(s.pendingMoves, oldSessionID)
|
|
s.logger.Info("transferred pending move between sessions",
|
|
zap.String("from_session_id", oldSessionID),
|
|
zap.String("to_session_id", newSessionID))
|
|
}
|
|
}
|
|
|
|
// SetPendingMove records a pending move for a session (replaces any existing one).
|
|
// The move is applied by handleAgentReady when the agent's current turn completes.
|
|
func (s *Service) SetPendingMove(ctx context.Context, sessionID string, move *PendingMove) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
move.QueuedAt = time.Now()
|
|
s.pendingMoves[sessionID] = move
|
|
s.logger.Info("pending move recorded",
|
|
zap.String("session_id", sessionID),
|
|
zap.String("task_id", move.TaskID),
|
|
zap.String("workflow_step_id", move.WorkflowStepID))
|
|
}
|
|
|
|
// TakePendingMove retrieves and removes the pending move for a session.
|
|
func (s *Service) TakePendingMove(ctx context.Context, sessionID string) (*PendingMove, bool) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
move, exists := s.pendingMoves[sessionID]
|
|
if !exists {
|
|
return nil, false
|
|
}
|
|
delete(s.pendingMoves, sessionID)
|
|
return move, true
|
|
}
|
|
|
|
// QueueMessage queues a message for a session (replaces existing queued message)
|
|
func (s *Service) QueueMessage(ctx context.Context, sessionID, taskID, content, model, userID string, planMode bool, attachments []MessageAttachment) (*QueuedMessage, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
msg := &QueuedMessage{
|
|
ID: uuid.New().String(),
|
|
SessionID: sessionID,
|
|
TaskID: taskID,
|
|
Content: content,
|
|
Model: model,
|
|
PlanMode: planMode,
|
|
Attachments: attachments,
|
|
QueuedAt: time.Now(),
|
|
QueuedBy: userID,
|
|
}
|
|
|
|
s.queued[sessionID] = msg
|
|
s.logger.Info("message queued",
|
|
zap.String("session_id", sessionID),
|
|
zap.String("task_id", taskID),
|
|
zap.Int("content_length", len(content)))
|
|
|
|
return msg, nil
|
|
}
|
|
|
|
// TakeQueued retrieves and removes the queued message for a session
|
|
func (s *Service) TakeQueued(ctx context.Context, sessionID string) (*QueuedMessage, bool) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
msg, exists := s.queued[sessionID]
|
|
if !exists {
|
|
return nil, false
|
|
}
|
|
|
|
delete(s.queued, sessionID)
|
|
s.logger.Info("message dequeued",
|
|
zap.String("session_id", sessionID),
|
|
zap.String("queue_id", msg.ID))
|
|
|
|
return msg, true
|
|
}
|
|
|
|
// CancelQueued removes a queued message without consuming it
|
|
func (s *Service) CancelQueued(ctx context.Context, sessionID string) (*QueuedMessage, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
msg, exists := s.queued[sessionID]
|
|
if !exists {
|
|
return nil, fmt.Errorf("no queued message for session %s", sessionID)
|
|
}
|
|
|
|
delete(s.queued, sessionID)
|
|
s.logger.Info("message queue cancelled",
|
|
zap.String("session_id", sessionID),
|
|
zap.String("queue_id", msg.ID))
|
|
|
|
return msg, nil
|
|
}
|
|
|
|
// GetStatus returns the queue status for a session
|
|
func (s *Service) GetStatus(ctx context.Context, sessionID string) *QueueStatus {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
|
|
msg, exists := s.queued[sessionID]
|
|
return &QueueStatus{
|
|
IsQueued: exists,
|
|
Message: msg,
|
|
}
|
|
}
|
|
|
|
// AppendContent appends content to an existing queued message.
|
|
// Returns an error if no message is queued (caller should use QueueMessage instead).
|
|
func (s *Service) AppendContent(ctx context.Context, sessionID, content string) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
msg, exists := s.queued[sessionID]
|
|
if !exists {
|
|
return fmt.Errorf("no queued message for session %s", sessionID)
|
|
}
|
|
|
|
msg.Content = msg.Content + "\n\n---\n\n" + content
|
|
s.logger.Info("content appended to queued message",
|
|
zap.String("session_id", sessionID),
|
|
zap.Int("appended_length", len(content)),
|
|
zap.Int("total_length", len(msg.Content)))
|
|
|
|
return nil
|
|
}
|
|
|
|
// UpdateMessage updates an existing queued message (for arrow up editing)
|
|
func (s *Service) UpdateMessage(ctx context.Context, sessionID, content string) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
msg, exists := s.queued[sessionID]
|
|
if !exists {
|
|
return fmt.Errorf("no queued message for session %s", sessionID)
|
|
}
|
|
|
|
msg.Content = content
|
|
s.logger.Info("queued message updated",
|
|
zap.String("session_id", sessionID),
|
|
zap.Int("new_length", len(content)))
|
|
|
|
return nil
|
|
}
|