feat(orchestrator): deferred task move with hand-off prompt + boot/turn-end event split (#743)
* 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>
This commit is contained in:
@@ -513,7 +513,7 @@ func registerMCPAndDebugRoutes(
|
||||
) {
|
||||
mcpHandlers := mcphandlers.NewHandlers(
|
||||
p.taskSvc, wfCtrl,
|
||||
clarificationStore, p.msgCreator, p.taskRepo, p.taskRepo, p.eventBus, planService, p.orchestratorSvc, p.log,
|
||||
clarificationStore, p.msgCreator, p.taskRepo, p.taskRepo, p.eventBus, planService, p.orchestratorSvc, p.orchestratorSvc.GetMessageQueue(), p.log,
|
||||
)
|
||||
// Wire config-mode dependencies for agent-native configuration
|
||||
mcpHandlers.SetConfigDeps(p.services.Workflow, p.agentSettingsController, p.mcpConfigSvc)
|
||||
|
||||
@@ -341,7 +341,12 @@ func (m *Manager) ResetAgentContext(ctx context.Context, executionID string) err
|
||||
zap.String("new_acp_session_id", newSessionID))
|
||||
|
||||
m.eventPublisher.PublishAgentEvent(ctx, events.AgentContextReset, execution)
|
||||
m.eventPublisher.PublishAgentEvent(ctx, events.AgentReady, execution)
|
||||
// Boot-equivalent signal: a fresh ACP session is alive but no turn has run yet.
|
||||
// Use AgentBootReady so the orchestrator routes this to handleAgentBootReady
|
||||
// (idle/WAITING transition) rather than handleAgentReady (turn-end transition,
|
||||
// which would fire on_turn_complete against the current step — the original
|
||||
// boot-vs-turn ambiguity bug).
|
||||
m.eventPublisher.PublishAgentEvent(ctx, events.AgentBootReady, execution)
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -595,9 +600,11 @@ func (m *Manager) initializeACPSessionForRestart(
|
||||
m.sessionManager.eventPublisher.PublishACPSessionCreated(execution, result.SessionID)
|
||||
}
|
||||
|
||||
// Mark execution as ready
|
||||
// Mark execution as ready. This is a *boot* signal — initializeACPSessionForRestart
|
||||
// is the post-restart init path and no turn has run yet, so AgentBootReady (not
|
||||
// AgentReady) is what subscribers want to route on.
|
||||
m.executionStore.UpdateStatus(execution.ID, v1.AgentStatusReady)
|
||||
m.eventPublisher.PublishAgentEvent(ctx, events.AgentReady, execution)
|
||||
m.eventPublisher.PublishAgentEvent(ctx, events.AgentBootReady, execution)
|
||||
|
||||
return nil
|
||||
}
|
||||
@@ -813,42 +820,62 @@ func (m *Manager) UpdateStatus(executionID string, status v1.AgentStatus) error
|
||||
return nil
|
||||
}
|
||||
|
||||
// MarkReady marks an execution as ready for follow-up prompts.
|
||||
// MarkReady marks an execution as ready for follow-up prompts AFTER A TURN.
|
||||
// Use MarkBootReady instead when the agent has just initialized and hasn't yet
|
||||
// processed a turn — orchestrator subscribers rely on the distinction.
|
||||
//
|
||||
// This transitions the execution to the "ready" state, indicating the agent has finished
|
||||
// processing the current prompt and is waiting for user input. This is called:
|
||||
// - After agent initialization completes (session loaded, workspace ready)
|
||||
// - After agent finishes processing a prompt (via stream completion event)
|
||||
// - After cancelling an agent turn (to allow new prompts)
|
||||
// processing the current prompt and is waiting for user input. Called when:
|
||||
// - Agent finishes processing a prompt (via stream completion event)
|
||||
// - User cancels an agent turn (to allow new prompts)
|
||||
//
|
||||
// State Machine Transitions:
|
||||
//
|
||||
// Running -> Ready (after prompt completion)
|
||||
// Any -> Ready (after cancel)
|
||||
//
|
||||
// Publishes events.AgentReady. Returns error if execution not found.
|
||||
func (m *Manager) MarkReady(executionID string) error {
|
||||
return m.markReadyEvent(executionID, events.AgentReady)
|
||||
}
|
||||
|
||||
// MarkBootReady marks a freshly-initialized execution as ready for its first
|
||||
// prompt. Distinct from MarkReady so the orchestrator can disambiguate boot
|
||||
// signals from turn-end signals without race-prone flag tracking. Use this
|
||||
// from session/init paths and post-context-reset; use MarkReady from the
|
||||
// turn-completion path.
|
||||
//
|
||||
// State Machine Transitions:
|
||||
//
|
||||
// Starting -> Ready (after initialization)
|
||||
// Running -> Ready (after prompt completion)
|
||||
// Any -> Ready (after cancel)
|
||||
//
|
||||
// Publishes an AgentReady event to notify subscribers (frontend, orchestrator).
|
||||
//
|
||||
// Returns error if execution not found.
|
||||
func (m *Manager) MarkReady(executionID string) error {
|
||||
// Publishes events.AgentBootReady. Returns error if execution not found.
|
||||
func (m *Manager) MarkBootReady(executionID string) error {
|
||||
return m.markReadyEvent(executionID, events.AgentBootReady)
|
||||
}
|
||||
|
||||
// markReadyEvent is the shared body of MarkReady / MarkBootReady — both flip
|
||||
// the execution to the Ready status and publish their respective event type.
|
||||
func (m *Manager) markReadyEvent(executionID, eventType string) error {
|
||||
execution, exists := m.executionStore.Get(executionID)
|
||||
if !exists {
|
||||
return fmt.Errorf("execution %q not found", executionID)
|
||||
}
|
||||
|
||||
// Skip if already ready (prevents duplicate events)
|
||||
// Skip if already ready (prevents duplicate events). This guard is shared
|
||||
// across MarkReady and MarkBootReady — once Ready is set, neither type fires
|
||||
// again until the next status transition (Running on prompt, Stopped on stop).
|
||||
if execution.Status == v1.AgentStatusReady {
|
||||
return nil
|
||||
}
|
||||
|
||||
m.executionStore.UpdateStatus(executionID, v1.AgentStatusReady)
|
||||
|
||||
m.logger.Info("execution ready for follow-up prompts",
|
||||
zap.String("execution_id", executionID))
|
||||
|
||||
// Publish ready event
|
||||
m.eventPublisher.PublishAgentEvent(context.Background(), events.AgentReady, execution)
|
||||
m.logger.Info("execution ready",
|
||||
zap.String("execution_id", executionID),
|
||||
zap.String("event_type", eventType))
|
||||
|
||||
m.eventPublisher.PublishAgentEvent(context.Background(), eventType, execution)
|
||||
return nil
|
||||
}
|
||||
|
||||
|
||||
@@ -251,8 +251,11 @@ func TestManager_RestartAgentProcess_Success(t *testing.T) {
|
||||
for _, ev := range mockBus.PublishedEvents {
|
||||
eventTypes = append(eventTypes, ev.Type)
|
||||
}
|
||||
if !slices.Contains(eventTypes, events.AgentReady) {
|
||||
t.Fatalf("expected %q event, got %v", events.AgentReady, eventTypes)
|
||||
// Restart is a boot scenario — initializeACPSessionForRestart publishes
|
||||
// AgentBootReady (not AgentReady) so the orchestrator routes it to
|
||||
// handleAgentBootReady rather than evaluating on_turn_complete.
|
||||
if !slices.Contains(eventTypes, events.AgentBootReady) {
|
||||
t.Fatalf("expected %q event, got %v", events.AgentBootReady, eventTypes)
|
||||
}
|
||||
if !slices.Contains(eventTypes, events.AgentACPSessionCreated) {
|
||||
t.Fatalf("expected %q event, got %v", events.AgentACPSessionCreated, eventTypes)
|
||||
|
||||
@@ -157,8 +157,12 @@ func (m *Manager) resolveProfileModelAndMode(ctx context.Context, profileID stri
|
||||
return info.Model, info.Mode
|
||||
}
|
||||
|
||||
// initializeACPSession delegates to SessionManager for full ACP session initialization and prompting
|
||||
// initializeACPSession delegates to SessionManager for full ACP session initialization and prompting.
|
||||
// We pass MarkBootReady (not MarkReady) for the no-prompt branches: dispatchInitialPrompt only
|
||||
// invokes the callback when there's no taskDescription/attachments to send, which is a *boot*
|
||||
// signal (the agent has never run a turn). When there IS a prompt, the callback is unused and
|
||||
// MarkReady fires later from handleCompleteEvent — that path is the true turn-end.
|
||||
func (m *Manager) initializeACPSession(ctx context.Context, execution *AgentExecution, agentConfig agents.Agent, taskDescription string, attachments []MessageAttachment, mcpServers []agentctltypes.McpServer) error {
|
||||
profileModel, profileMode := m.resolveProfileModelAndMode(ctx, execution.AgentProfileID)
|
||||
return m.sessionManager.InitializeAndPrompt(ctx, execution, agentConfig, taskDescription, attachments, mcpServers, m.MarkReady, profileModel, profileMode)
|
||||
return m.sessionManager.InitializeAndPrompt(ctx, execution, agentConfig, taskDescription, attachments, mcpServers, m.MarkBootReady, profileModel, profileMode)
|
||||
}
|
||||
|
||||
@@ -119,7 +119,8 @@ const (
|
||||
const (
|
||||
AgentStarted = "agent.started"
|
||||
AgentRunning = "agent.running"
|
||||
AgentReady = "agent.ready" // Agent finished prompt, ready for follow-up
|
||||
AgentBootReady = "agent.boot_ready" // Agent's ACP session initialized, ready to receive its first prompt. Distinct from AgentReady so the orchestrator can tell a boot signal apart from a turn-end without flag-based disambiguation.
|
||||
AgentReady = "agent.ready" // Agent finished a prompt turn, ready for follow-up
|
||||
AgentCompleted = "agent.completed"
|
||||
AgentFailed = "agent.failed"
|
||||
AgentStopped = "agent.stopped"
|
||||
|
||||
@@ -18,7 +18,7 @@ func setupMCPTestServer(t *testing.T) (*TestServer, string, string, string, stri
|
||||
ts := NewTestServer(t)
|
||||
|
||||
// Register MCP handlers on the gateway dispatcher
|
||||
mcpH := mcphandlers.NewHandlers(ts.TaskSvc, nil, nil, nil, nil, nil, nil, nil, nil, ts.Logger)
|
||||
mcpH := mcphandlers.NewHandlers(ts.TaskSvc, nil, nil, nil, nil, nil, nil, nil, nil, nil, ts.Logger)
|
||||
mcpH.RegisterHandlers(ts.Gateway.Dispatcher)
|
||||
|
||||
client := NewWSClient(t, ts.Server.URL)
|
||||
|
||||
@@ -6,6 +6,7 @@ import (
|
||||
"testing"
|
||||
|
||||
"github.com/kandev/kandev/internal/common/logger"
|
||||
"github.com/kandev/kandev/internal/orchestrator/messagequeue"
|
||||
ws "github.com/kandev/kandev/pkg/websocket"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
@@ -341,6 +342,84 @@ func TestHandleMoveTask_InvalidPayload(t *testing.T) {
|
||||
assertWSError(t, resp, ws.ErrorCodeBadRequest)
|
||||
}
|
||||
|
||||
// recordingMessageQueuer captures QueueMessage calls for assertion.
|
||||
type recordingMessageQueuer struct {
|
||||
calls []messagequeue.QueuedMessage
|
||||
}
|
||||
|
||||
func (r *recordingMessageQueuer) QueueMessage(_ context.Context, sessionID, taskID, content, model, userID string, planMode bool, _ []messagequeue.MessageAttachment) (*messagequeue.QueuedMessage, error) {
|
||||
msg := messagequeue.QueuedMessage{
|
||||
SessionID: sessionID,
|
||||
TaskID: taskID,
|
||||
Content: content,
|
||||
Model: model,
|
||||
PlanMode: planMode,
|
||||
QueuedBy: userID,
|
||||
}
|
||||
r.calls = append(r.calls, msg)
|
||||
return &msg, nil
|
||||
}
|
||||
|
||||
func (r *recordingMessageQueuer) SetPendingMove(_ context.Context, _ string, _ *messagequeue.PendingMove) {
|
||||
}
|
||||
|
||||
// TakeQueued is a no-op stub — the unit tests below don't exercise rollback,
|
||||
// they just exercise QueueMessage. Returning (nil, false) is consistent with
|
||||
// "nothing to take", which is what the rollback path checks before logging.
|
||||
func (r *recordingMessageQueuer) TakeQueued(_ context.Context, _ string) (*messagequeue.QueuedMessage, bool) {
|
||||
return nil, false
|
||||
}
|
||||
|
||||
// TestQueueMoveTaskPrompt_NilQueueReturnsError ensures the call is safe (no panic)
|
||||
// and surfaces a descriptive error so callers can fail fast instead of silently
|
||||
// dropping the user-supplied prompt.
|
||||
func TestQueueMoveTaskPrompt_NilQueueReturnsError(t *testing.T) {
|
||||
h := &Handlers{logger: testLogger(t).WithFields()}
|
||||
|
||||
err := h.queueMoveTaskPrompt(context.Background(), "task-1", "session-1", "fix issues")
|
||||
require.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "message queue")
|
||||
}
|
||||
|
||||
// TestQueueMoveTaskPrompt_EmptySessionIDReturnsError ensures a missing session ID
|
||||
// surfaces an error rather than silently no-op'ing — without a session there's
|
||||
// nowhere to deliver the prompt.
|
||||
func TestQueueMoveTaskPrompt_EmptySessionIDReturnsError(t *testing.T) {
|
||||
queue := &recordingMessageQueuer{}
|
||||
h := &Handlers{
|
||||
messageQueue: queue,
|
||||
logger: testLogger(t).WithFields(),
|
||||
}
|
||||
|
||||
err := h.queueMoveTaskPrompt(context.Background(), "task-1", "", "fix issues")
|
||||
require.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "primary session")
|
||||
assert.Empty(t, queue.calls, "queue must not be invoked without a session ID")
|
||||
}
|
||||
|
||||
// TestQueueMoveTaskPrompt_QueuesWithExpectedFields verifies the happy-path
|
||||
// invocation: the prompt is queued on the resolved session with the expected
|
||||
// metadata (sender = "mcp-move-task", plan mode disabled, no model override).
|
||||
func TestQueueMoveTaskPrompt_QueuesWithExpectedFields(t *testing.T) {
|
||||
queue := &recordingMessageQueuer{}
|
||||
h := &Handlers{
|
||||
messageQueue: queue,
|
||||
logger: testLogger(t).WithFields(),
|
||||
}
|
||||
|
||||
err := h.queueMoveTaskPrompt(context.Background(), "task-1", "session-99", "Please fix the failing test in foo_test.go")
|
||||
require.NoError(t, err)
|
||||
|
||||
require.Len(t, queue.calls, 1)
|
||||
got := queue.calls[0]
|
||||
assert.Equal(t, "session-99", got.SessionID)
|
||||
assert.Equal(t, "task-1", got.TaskID)
|
||||
assert.Equal(t, "Please fix the failing test in foo_test.go", got.Content)
|
||||
assert.Equal(t, "mcp-move-task", got.QueuedBy)
|
||||
assert.False(t, got.PlanMode)
|
||||
assert.Equal(t, "", got.Model)
|
||||
}
|
||||
|
||||
func TestHandleDeleteTask_MissingTaskID(t *testing.T) {
|
||||
h := &Handlers{}
|
||||
msg := makeWSMessage(t, ws.ActionMCPDeleteTask, map[string]string{})
|
||||
|
||||
@@ -3,8 +3,12 @@ package handlers
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/kandev/kandev/internal/orchestrator/messagequeue"
|
||||
"github.com/kandev/kandev/internal/task/dto"
|
||||
"github.com/kandev/kandev/internal/task/models"
|
||||
v1 "github.com/kandev/kandev/pkg/api/v1"
|
||||
ws "github.com/kandev/kandev/pkg/websocket"
|
||||
"go.uber.org/zap"
|
||||
@@ -16,6 +20,7 @@ func (h *Handlers) handleMoveTask(ctx context.Context, msg *ws.Message) (*ws.Mes
|
||||
WorkflowID string `json:"workflow_id"`
|
||||
WorkflowStepID string `json:"workflow_step_id"`
|
||||
Position int `json:"position"`
|
||||
Prompt string `json:"prompt"`
|
||||
}
|
||||
if err := json.Unmarshal(msg.Payload, &req); err != nil {
|
||||
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeBadRequest, "Invalid payload: "+err.Error(), nil)
|
||||
@@ -30,14 +35,186 @@ func (h *Handlers) handleMoveTask(ctx context.Context, msg *ws.Message) (*ws.Mes
|
||||
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "workflow_step_id is required", nil)
|
||||
}
|
||||
|
||||
// Prompt is OPTIONAL — config-mode/admin moves don't always have an agent
|
||||
// to hand off to. When supplied, it activates the deferred-move path that
|
||||
// hands the receiving agent a directive on its first turn at the new step.
|
||||
// When omitted, we just move the task and return.
|
||||
session, lookupErr := h.lookupSession(ctx, req.TaskID)
|
||||
if lookupErr != nil {
|
||||
// Backend lookup failure is an internal error, not validation — don't
|
||||
// collapse it into "you have no session" downstream.
|
||||
h.logger.Error("move_task: failed to look up primary session",
|
||||
zap.String("task_id", req.TaskID), zap.Error(lookupErr))
|
||||
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError,
|
||||
"failed to look up task's primary session", nil)
|
||||
}
|
||||
|
||||
// Active source session + prompt → deferred path. Running MoveTask now
|
||||
// would race on_enter processing against the agent's still-active turn —
|
||||
// corrupting session state and orphaning the queued prompt. Defer until
|
||||
// handleAgentReady fires applyPendingMove on turn-end.
|
||||
if req.Prompt != "" && session != nil &&
|
||||
(session.State == models.TaskSessionStateRunning || session.State == models.TaskSessionStateStarting) {
|
||||
return h.deferMoveTaskWithPrompt(ctx, msg, req, session)
|
||||
}
|
||||
|
||||
// Idle path — apply immediately. If a prompt was supplied, queue it on the
|
||||
// session so the receiving agent's next turn picks it up; if not, just move.
|
||||
return h.applyMoveTaskImmediate(ctx, msg, req, session)
|
||||
}
|
||||
|
||||
// deferMoveTaskWithPrompt queues the hand-off prompt + records a PendingMove
|
||||
// for the agent's turn-end handler to apply. Used when the source session is
|
||||
// active and the caller supplied a prompt. Returns a synthetic moved-task DTO
|
||||
// so the agent's tool call resolves successfully and ends the turn cleanly.
|
||||
func (h *Handlers) deferMoveTaskWithPrompt(
|
||||
ctx context.Context,
|
||||
msg *ws.Message,
|
||||
req struct {
|
||||
TaskID string `json:"task_id"`
|
||||
WorkflowID string `json:"workflow_id"`
|
||||
WorkflowStepID string `json:"workflow_step_id"`
|
||||
Position int `json:"position"`
|
||||
Prompt string `json:"prompt"`
|
||||
},
|
||||
session *models.TaskSession,
|
||||
) (*ws.Message, error) {
|
||||
if h.messageQueue == nil {
|
||||
h.logger.Error("move_task: message queue not configured; cannot defer move from active session",
|
||||
zap.String("task_id", req.TaskID), zap.String("session_id", session.ID))
|
||||
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError,
|
||||
"move_task requires message queue support while the source session is active", nil)
|
||||
}
|
||||
wrapped := "You were moved to this step with the following message: " + req.Prompt
|
||||
if err := h.queueMoveTaskPrompt(ctx, req.TaskID, session.ID, wrapped); err != nil {
|
||||
h.logger.Error("move_task: failed to queue hand-off prompt",
|
||||
zap.String("task_id", req.TaskID), zap.String("session_id", session.ID), zap.Error(err))
|
||||
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError,
|
||||
"failed to queue move_task hand-off prompt", nil)
|
||||
}
|
||||
h.messageQueue.SetPendingMove(ctx, session.ID, &messagequeue.PendingMove{
|
||||
TaskID: req.TaskID,
|
||||
WorkflowID: req.WorkflowID,
|
||||
WorkflowStepID: req.WorkflowStepID,
|
||||
Position: req.Position,
|
||||
})
|
||||
return ws.NewResponse(msg.ID, msg.Action,
|
||||
h.synthesizeMovedTaskDTO(ctx, req.TaskID, req.WorkflowID, req.WorkflowStepID, req.Position))
|
||||
}
|
||||
|
||||
// applyMoveTaskImmediate runs the move now, optionally queueing a hand-off
|
||||
// prompt on the (idle) primary session beforehand. Used when the source
|
||||
// session is idle, when there's no source session at all, or when no prompt
|
||||
// was supplied (config-mode/admin moves).
|
||||
func (h *Handlers) applyMoveTaskImmediate(
|
||||
ctx context.Context,
|
||||
msg *ws.Message,
|
||||
req struct {
|
||||
TaskID string `json:"task_id"`
|
||||
WorkflowID string `json:"workflow_id"`
|
||||
WorkflowStepID string `json:"workflow_step_id"`
|
||||
Position int `json:"position"`
|
||||
Prompt string `json:"prompt"`
|
||||
},
|
||||
session *models.TaskSession,
|
||||
) (*ws.Message, error) {
|
||||
queuedSessionID := ""
|
||||
if req.Prompt != "" && session != nil {
|
||||
wrapped := "You were moved to this step with the following message: " + req.Prompt
|
||||
if err := h.queueMoveTaskPrompt(ctx, req.TaskID, session.ID, wrapped); err != nil {
|
||||
h.logger.Error("move_task: failed to queue hand-off prompt for idle session",
|
||||
zap.String("task_id", req.TaskID), zap.String("session_id", session.ID), zap.Error(err))
|
||||
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError,
|
||||
"failed to queue move_task hand-off prompt", nil)
|
||||
}
|
||||
queuedSessionID = session.ID
|
||||
}
|
||||
|
||||
result, err := h.taskSvc.MoveTask(ctx, req.TaskID, req.WorkflowID, req.WorkflowStepID, req.Position)
|
||||
if err != nil {
|
||||
// Roll back the queued prompt — without this, the next turn would
|
||||
// deliver a "You were moved to this step…" message for a transition
|
||||
// that didn't actually happen.
|
||||
if queuedSessionID != "" && h.messageQueue != nil {
|
||||
if _, ok := h.messageQueue.TakeQueued(ctx, queuedSessionID); ok {
|
||||
h.logger.Warn("move_task: dropped queued hand-off prompt after MoveTask failure",
|
||||
zap.String("task_id", req.TaskID), zap.String("session_id", queuedSessionID))
|
||||
}
|
||||
}
|
||||
h.logger.Error("failed to move task", zap.Error(err))
|
||||
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, "Failed to move task", nil)
|
||||
}
|
||||
return ws.NewResponse(msg.ID, msg.Action, dto.FromTask(result.Task))
|
||||
}
|
||||
|
||||
// synthesizeMovedTaskDTO returns a task DTO with the post-move step/workflow
|
||||
// values filled in. Used by the deferred-move path so the agent's tool call
|
||||
// sees a "successful move" response shape, freeing it to end the turn (which
|
||||
// is what triggers applyPendingMove). If we can't load the task, fall back to
|
||||
// a minimal map so the call still resolves.
|
||||
func (h *Handlers) synthesizeMovedTaskDTO(ctx context.Context, taskID, workflowID, workflowStepID string, position int) any {
|
||||
task, err := h.taskSvc.GetTask(ctx, taskID)
|
||||
if err != nil || task == nil {
|
||||
h.logger.Warn("failed to load task for synthetic move response",
|
||||
zap.String("task_id", taskID),
|
||||
zap.Error(err))
|
||||
return map[string]any{
|
||||
"id": taskID,
|
||||
"workflow_id": workflowID,
|
||||
"workflow_step_id": workflowStepID,
|
||||
"position": position,
|
||||
}
|
||||
}
|
||||
clone := *task
|
||||
clone.WorkflowID = workflowID
|
||||
clone.WorkflowStepID = workflowStepID
|
||||
clone.Position = position
|
||||
return dto.FromTask(&clone)
|
||||
}
|
||||
|
||||
// lookupSession returns the task's primary session.
|
||||
// - (session, nil) — task has a primary session.
|
||||
// - (nil, nil) — task has no primary session yet (legitimate "empty"
|
||||
// state — task was created but no agent has been launched). The
|
||||
// repository signals this with a "no primary session found for task:"
|
||||
// error string; we treat it as a not-found rather than a failure so the
|
||||
// caller can fall through to the idle-move path instead of rejecting the
|
||||
// request.
|
||||
// - (nil, err) — real backend lookup failure (DB error, etc.). The
|
||||
// caller should map this to an internal error rather than collapsing it
|
||||
// into "no session" downstream.
|
||||
func (h *Handlers) lookupSession(ctx context.Context, taskID string) (*models.TaskSession, error) {
|
||||
session, err := h.taskSvc.GetPrimarySession(ctx, taskID)
|
||||
if err != nil {
|
||||
// "no primary session found for task: <id>" is the repo's not-found
|
||||
// signal — see scanTaskSession's noRowsErr formatting. Match by
|
||||
// substring; there's no exported sentinel to errors.Is against.
|
||||
if strings.Contains(err.Error(), "no primary session found for task") {
|
||||
return nil, nil
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
return session, nil
|
||||
}
|
||||
|
||||
// queueMoveTaskPrompt enqueues a user-supplied prompt on the task's primary session.
|
||||
// Returns an error when the queue itself is missing or QueueMessage fails — the
|
||||
// caller decides whether to fail the whole move (running-session deferred path)
|
||||
// or proceed (idle path), since a queue failure makes the deferred contract
|
||||
// impossible to honor.
|
||||
func (h *Handlers) queueMoveTaskPrompt(ctx context.Context, taskID, sessionID, prompt string) error {
|
||||
if h.messageQueue == nil {
|
||||
return fmt.Errorf("message queue is unavailable")
|
||||
}
|
||||
if sessionID == "" {
|
||||
return fmt.Errorf("task has no primary session")
|
||||
}
|
||||
if _, err := h.messageQueue.QueueMessage(ctx, sessionID, taskID, prompt, "", "mcp-move-task", false, nil); err != nil {
|
||||
return fmt.Errorf("queue message: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (h *Handlers) handleDeleteTask(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
|
||||
taskID, err := unmarshalStringField(msg.Payload, "task_id")
|
||||
if err != nil {
|
||||
|
||||
@@ -17,6 +17,7 @@ import (
|
||||
"github.com/kandev/kandev/internal/events"
|
||||
"github.com/kandev/kandev/internal/events/bus"
|
||||
"github.com/kandev/kandev/internal/orchestrator"
|
||||
"github.com/kandev/kandev/internal/orchestrator/messagequeue"
|
||||
"github.com/kandev/kandev/internal/task/dto"
|
||||
"github.com/kandev/kandev/internal/task/models"
|
||||
"github.com/kandev/kandev/internal/task/service"
|
||||
@@ -60,6 +61,16 @@ type SessionLauncher interface {
|
||||
LaunchSession(ctx context.Context, req *orchestrator.LaunchSessionRequest) (*orchestrator.LaunchSessionResponse, error)
|
||||
}
|
||||
|
||||
// MessageQueuer queues a prompt message for delivery to a session on its next turn.
|
||||
// TakeQueued is exposed so move_task can roll back the hand-off prompt when the
|
||||
// underlying MoveTask call fails — without it, a queued "you were moved..."
|
||||
// message would survive a failed move and be delivered on the next agent turn.
|
||||
type MessageQueuer interface {
|
||||
QueueMessage(ctx context.Context, sessionID, taskID, content, model, userID string, planMode bool, attachments []messagequeue.MessageAttachment) (*messagequeue.QueuedMessage, error)
|
||||
SetPendingMove(ctx context.Context, sessionID string, move *messagequeue.PendingMove)
|
||||
TakeQueued(ctx context.Context, sessionID string) (*messagequeue.QueuedMessage, bool)
|
||||
}
|
||||
|
||||
// Handlers provides MCP WebSocket handlers.
|
||||
type Handlers struct {
|
||||
taskSvc *service.Service
|
||||
@@ -71,6 +82,7 @@ type Handlers struct {
|
||||
eventBus EventBus
|
||||
planService *service.PlanService
|
||||
sessionLauncher SessionLauncher
|
||||
messageQueue MessageQueuer
|
||||
logger *logger.Logger
|
||||
|
||||
// Config-mode dependencies (optional, set via SetConfigDeps)
|
||||
@@ -90,6 +102,7 @@ func NewHandlers(
|
||||
eventBus EventBus,
|
||||
planService *service.PlanService,
|
||||
sessionLauncher SessionLauncher,
|
||||
messageQueue MessageQueuer,
|
||||
log *logger.Logger,
|
||||
) *Handlers {
|
||||
return &Handlers{
|
||||
@@ -102,6 +115,7 @@ func NewHandlers(
|
||||
eventBus: eventBus,
|
||||
planService: planService,
|
||||
sessionLauncher: sessionLauncher,
|
||||
messageQueue: messageQueue,
|
||||
logger: log.WithFields(zap.String("component", "mcp-handlers")),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -247,11 +247,12 @@ func (s *Server) registerConfigTaskTools() {
|
||||
)
|
||||
s.mcpServer.AddTool(
|
||||
mcp.NewTool("move_task_kandev",
|
||||
mcp.WithDescription("Move a task to a different workflow step."),
|
||||
mcp.WithDescription("Move a task to a different workflow step. Optionally send a hand-off prompt to the receiving agent — required only when handing the task off mid-turn (e.g. QA → review) with specific instructions. Plain admin/config moves can omit prompt."),
|
||||
mcp.WithString("task_id", mcp.Required(), mcp.Description("The task ID")),
|
||||
mcp.WithString("workflow_id", mcp.Required(), mcp.Description("Target workflow ID")),
|
||||
mcp.WithString("workflow_step_id", mcp.Required(), mcp.Description("Target workflow step ID")),
|
||||
mcp.WithNumber("position", mcp.Description("Position within the step (0-based)")),
|
||||
mcp.WithString("prompt", mcp.Description("Optional hand-off message for the receiving agent. When supplied AND the source session is mid-turn, the move is deferred to the agent's turn-end and the prompt is delivered at the new step (concatenated after the step's own auto_start prompt, if any). Omit for plain admin/config moves where there's no agent to address.")),
|
||||
),
|
||||
s.wrapHandler("move_task_kandev", s.moveTaskHandler()),
|
||||
)
|
||||
@@ -519,11 +520,16 @@ func (s *Server) moveTaskHandler() server.ToolHandlerFunc {
|
||||
if err != nil {
|
||||
return mcp.NewToolResultError("workflow_step_id is required"), nil
|
||||
}
|
||||
// prompt is optional — only relevant when handing off mid-turn from one
|
||||
// agent to another. Admin/config moves of idle tasks omit it.
|
||||
payload := map[string]interface{}{
|
||||
"task_id": taskID,
|
||||
"workflow_id": workflowID,
|
||||
"workflow_step_id": stepID,
|
||||
}
|
||||
if prompt := req.GetString("prompt", ""); prompt != "" {
|
||||
payload["prompt"] = prompt
|
||||
}
|
||||
if args := req.GetArguments(); args["position"] != nil {
|
||||
payload["position"] = args["position"]
|
||||
}
|
||||
|
||||
@@ -307,7 +307,7 @@ func (s *Server) registerTools() {
|
||||
count++
|
||||
default: // ModeTask
|
||||
s.registerKanbanTools()
|
||||
count += 8
|
||||
count += 9
|
||||
if !s.disableAskQuestion {
|
||||
s.registerInteractionTools()
|
||||
count++
|
||||
@@ -379,6 +379,17 @@ func (s *Server) registerKanbanTools() {
|
||||
),
|
||||
s.wrapHandler("update_task_kandev", s.updateTaskHandler()),
|
||||
)
|
||||
s.mcpServer.AddTool(
|
||||
mcp.NewTool("move_task_kandev",
|
||||
mcp.WithDescription("Move a task to a different workflow step. Optionally send a hand-off prompt to the receiving agent — required only when handing the task off mid-turn (e.g. QA → review) with specific instructions. Plain admin/config moves can omit prompt."),
|
||||
mcp.WithString("task_id", mcp.Required(), mcp.Description("The task ID")),
|
||||
mcp.WithString("workflow_id", mcp.Required(), mcp.Description("Target workflow ID")),
|
||||
mcp.WithString("workflow_step_id", mcp.Required(), mcp.Description("Target workflow step ID")),
|
||||
mcp.WithNumber("position", mcp.Description("Position within the step (0-based)")),
|
||||
mcp.WithString("prompt", mcp.Description("Optional hand-off message for the receiving agent. When supplied AND the source session is mid-turn, the move is deferred to the agent's turn-end and the prompt is delivered at the new step (concatenated after the step's own auto_start prompt, if any). Omit for plain admin/config moves where there's no agent to address.")),
|
||||
),
|
||||
s.wrapHandler("move_task_kandev", s.moveTaskHandler()),
|
||||
)
|
||||
}
|
||||
|
||||
// registerCreateTaskTool registers the create_task_kandev tool. Shared between
|
||||
|
||||
@@ -42,6 +42,7 @@ func TestServerModeTask_RegistersCorrectTools(t *testing.T) {
|
||||
assert.Contains(t, tools, "list_tasks_kandev")
|
||||
assert.Contains(t, tools, "create_task_kandev")
|
||||
assert.Contains(t, tools, "update_task_kandev")
|
||||
assert.Contains(t, tools, "move_task_kandev")
|
||||
|
||||
// Task mode should have plan tools
|
||||
assert.Contains(t, tools, "create_task_plan_kandev")
|
||||
@@ -69,7 +70,6 @@ func TestServerModeTask_RegistersCorrectTools(t *testing.T) {
|
||||
assert.NotContains(t, tools, "update_agent_profile_kandev")
|
||||
assert.NotContains(t, tools, "get_mcp_config_kandev")
|
||||
assert.NotContains(t, tools, "update_mcp_config_kandev")
|
||||
assert.NotContains(t, tools, "move_task_kandev")
|
||||
assert.NotContains(t, tools, "delete_task_kandev")
|
||||
assert.NotContains(t, tools, "archive_task_kandev")
|
||||
assert.NotContains(t, tools, "list_executors_kandev")
|
||||
@@ -193,8 +193,8 @@ func TestServerModeTask_ToolCount(t *testing.T) {
|
||||
|
||||
s := New(backend, "test-session", "test-task", 10005, log, "", false, ModeTask)
|
||||
tools := getRegisteredToolNames(s)
|
||||
// 8 kanban + 1 interaction + 4 plan = 13
|
||||
assert.Equal(t, 13, len(tools))
|
||||
// 9 kanban + 1 interaction + 4 plan = 14
|
||||
assert.Equal(t, 14, len(tools))
|
||||
}
|
||||
|
||||
func TestServerModeConfig_ToolCount(t *testing.T) {
|
||||
|
||||
@@ -99,8 +99,79 @@ func (s *Service) requeueMessage(ctx context.Context, queuedMsg *messagequeue.Qu
|
||||
s.publishQueueStatusEvent(ctx, queuedMsg.SessionID)
|
||||
}
|
||||
|
||||
// handleAgentReady handles agent ready events (turn complete in passthrough mode)
|
||||
// This is called when the agent finishes processing and is waiting for input.
|
||||
// handleAgentBootReady handles the boot signal: an agent's ACP session has
|
||||
// finished initializing but no turn has run yet. This event is distinct from
|
||||
// agent.ready (turn-end) so the orchestrator never has to disambiguate the
|
||||
// two with race-prone flags.
|
||||
//
|
||||
// The only job here is to flip the session to WAITING_FOR_INPUT so callers
|
||||
// that are gating on that state (e.g. PromptTask's waitForSessionReady after
|
||||
// ensureSessionRunning kicked off ResumeSession) can proceed. Crucially we do
|
||||
// NOT call processOnTurnCompleteViaEngine — there's no turn to complete, and
|
||||
// stepping the workflow off a boot signal is what caused the production
|
||||
// ping-pong bug.
|
||||
func (s *Service) handleAgentBootReady(ctx context.Context, data watcher.AgentEventData) {
|
||||
if data.SessionID == "" {
|
||||
s.logger.Warn("missing session_id for agent boot ready event",
|
||||
zap.String("task_id", data.TaskID))
|
||||
return
|
||||
}
|
||||
|
||||
if s.isSessionResetInProgress(data.SessionID) {
|
||||
s.logger.Debug("ignoring agent.boot_ready while session reset is in progress",
|
||||
zap.String("task_id", data.TaskID),
|
||||
zap.String("session_id", data.SessionID))
|
||||
return
|
||||
}
|
||||
|
||||
session, err := s.repo.GetTaskSession(ctx, data.SessionID)
|
||||
if err != nil {
|
||||
s.logger.Warn("failed to load session for agent.boot_ready",
|
||||
zap.String("task_id", data.TaskID),
|
||||
zap.String("session_id", data.SessionID),
|
||||
zap.Error(err))
|
||||
return
|
||||
}
|
||||
|
||||
// Stale event: the session has rotated to a different execution. The agent
|
||||
// process tied to data.AgentExecutionID is no longer the active one for this
|
||||
// session, so its boot signal is irrelevant.
|
||||
if data.AgentExecutionID != "" && session.AgentExecutionID != "" && session.AgentExecutionID != data.AgentExecutionID {
|
||||
s.logger.Debug("ignoring stale agent.boot_ready for non-active execution",
|
||||
zap.String("task_id", data.TaskID),
|
||||
zap.String("session_id", data.SessionID),
|
||||
zap.String("event_execution_id", data.AgentExecutionID),
|
||||
zap.String("active_execution_id", session.AgentExecutionID))
|
||||
return
|
||||
}
|
||||
|
||||
// Terminal sessions never need a boot signal — if a stale init event
|
||||
// arrives after the session was completed/cancelled, just drop it.
|
||||
if isTerminalSessionState(session.State) {
|
||||
s.logger.Debug("ignoring agent.boot_ready for terminal session",
|
||||
zap.String("task_id", data.TaskID),
|
||||
zap.String("session_id", data.SessionID),
|
||||
zap.String("session_state", string(session.State)))
|
||||
return
|
||||
}
|
||||
|
||||
// Idempotent: if the session is already WAITING_FOR_INPUT (e.g. revived
|
||||
// from a previously launched session and the boot signal arrived faster
|
||||
// than persistResumeState wrote STARTING), skip — there's nothing to flip
|
||||
// and waitForSessionReady's poll will pick it up.
|
||||
if session.State == models.TaskSessionStateWaitingForInput {
|
||||
s.logger.Debug("agent.boot_ready: session already WAITING_FOR_INPUT, no-op",
|
||||
zap.String("session_id", data.SessionID))
|
||||
return
|
||||
}
|
||||
|
||||
s.setSessionWaitingForInput(ctx, data.TaskID, data.SessionID, session)
|
||||
}
|
||||
|
||||
// handleAgentReady handles turn-end ready events: the agent finished processing
|
||||
// a prompt and is waiting for the next input. This is the *only* event that
|
||||
// should evaluate workflow on_turn_complete actions — boot signals route
|
||||
// through handleAgentBootReady instead.
|
||||
func (s *Service) handleAgentReady(ctx context.Context, data watcher.AgentEventData) {
|
||||
|
||||
if data.SessionID == "" {
|
||||
@@ -146,6 +217,15 @@ func (s *Service) handleAgentReady(ctx context.Context, data watcher.AgentEventD
|
||||
// Complete the current turn
|
||||
s.completeTurnForSession(ctx, data.SessionID)
|
||||
|
||||
// A move_task_kandev call during this turn deferred the actual move to
|
||||
// avoid racing on_enter against the running turn. Apply it now: the move
|
||||
// is the explicit transition the agent requested, so skip the regular
|
||||
// on_turn_complete evaluation against the (still old) step.
|
||||
if pendingMove, exists := s.messageQueue.TakePendingMove(ctx, data.SessionID); exists {
|
||||
s.applyPendingMove(ctx, data.TaskID, data.SessionID, session, pendingMove)
|
||||
return
|
||||
}
|
||||
|
||||
// Check for workflow transition based on session's current step.
|
||||
// Uses the engine when available; falls back to legacy evaluation.
|
||||
// The ViaEngine method handles setSessionWaitingForInput internally when no transition occurs.
|
||||
@@ -318,6 +398,36 @@ func (s *Service) handleAgentCompleted(ctx context.Context, data watcher.AgentEv
|
||||
zap.Error(err))
|
||||
return
|
||||
}
|
||||
|
||||
// Skip transition logic when this event is the side-effect of a deliberate
|
||||
// stop (e.g. a workflow profile-switch calling completeAndStopSession). Two
|
||||
// signals identify that case:
|
||||
// - Stale execution ID: the session has already adopted a new agent
|
||||
// execution (or cleared the old one), so this event refers to a stopped
|
||||
// run, not the current one.
|
||||
// - Terminal session state: completeAndStopSession set state to COMPLETED
|
||||
// before StopAgent fired this event.
|
||||
// Without this guard, processOnTurnCompleteViaEngine evaluates the *current*
|
||||
// task step (which has already moved past where this agent ran) and triggers
|
||||
// spurious transitions — manifesting as task-step ping-pong on profile switches.
|
||||
if data.AgentExecutionID != "" && session.AgentExecutionID != "" && session.AgentExecutionID != data.AgentExecutionID {
|
||||
s.logger.Debug("ignoring stale agent.completed for non-active execution",
|
||||
zap.String("task_id", data.TaskID),
|
||||
zap.String("session_id", data.SessionID),
|
||||
zap.String("event_execution_id", data.AgentExecutionID),
|
||||
zap.String("active_execution_id", session.AgentExecutionID))
|
||||
go s.cleanupAgentExecution(data.AgentExecutionID, data.TaskID, data.SessionID)
|
||||
return
|
||||
}
|
||||
if isTerminalSessionState(session.State) {
|
||||
s.logger.Debug("ignoring agent.completed; session already in terminal state (deliberate stop)",
|
||||
zap.String("task_id", data.TaskID),
|
||||
zap.String("session_id", data.SessionID),
|
||||
zap.String("session_state", string(session.State)))
|
||||
go s.cleanupAgentExecution(data.AgentExecutionID, data.TaskID, data.SessionID)
|
||||
return
|
||||
}
|
||||
|
||||
transitioned := s.processOnTurnCompleteViaEngine(ctx, data.TaskID, session)
|
||||
|
||||
// If no workflow transition occurred, move task to REVIEW state for user review
|
||||
|
||||
@@ -0,0 +1,588 @@
|
||||
package orchestrator
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/kandev/kandev/internal/orchestrator/executor"
|
||||
"github.com/kandev/kandev/internal/orchestrator/messagequeue"
|
||||
"github.com/kandev/kandev/internal/orchestrator/queue"
|
||||
"github.com/kandev/kandev/internal/orchestrator/scheduler"
|
||||
"github.com/kandev/kandev/internal/orchestrator/watcher"
|
||||
"github.com/kandev/kandev/internal/task/models"
|
||||
sqliterepo "github.com/kandev/kandev/internal/task/repository/sqlite"
|
||||
wfmodels "github.com/kandev/kandev/internal/workflow/models"
|
||||
v1 "github.com/kandev/kandev/pkg/api/v1"
|
||||
)
|
||||
|
||||
// TestPendingMove_ReviewToInProgress_OneTransitionOnly reproduces the production bug
|
||||
// observed at task a99d863e ("buggy fibo"): a QA agent calls move_task_kandev to send
|
||||
// the task back to "In Progress" with a hand-off prompt, but the deferred-move flow
|
||||
// triggers spurious additional transitions and the task ends up at "Reviewed" instead.
|
||||
//
|
||||
// Workflow (simplified, matches the user's actual setup):
|
||||
//
|
||||
// [In Progress] --on_turn_complete--> [In Review] --on_turn_complete--> [Reviewed]
|
||||
// on_enter: auto_start_agent on_enter: auto_start_agent
|
||||
// profile-impl profile-review
|
||||
//
|
||||
// Both on_turn_complete rules are unconditional — any agent.ready event triggers
|
||||
// a transition. That's the workflow author's choice, but the orchestrator must
|
||||
// not feed it spurious ready events. The deferred-move feature must produce
|
||||
// exactly one transition: "In Review" → "In Progress". Anything else (e.g.
|
||||
// "In Progress" → "In Review", or worse, "In Review" → "Reviewed" via a stale
|
||||
// ready) is the bug.
|
||||
//
|
||||
// Scenario the test sets up:
|
||||
// - Task is currently at "In Review" (the QA step).
|
||||
// - Two sessions exist: an "In Progress" session (profile-impl, completed earlier
|
||||
// when the workflow first transitioned to Review) and an "In Review" session
|
||||
// (profile-review, currently RUNNING, primary).
|
||||
// - QA called move_task_kandev mid-turn → handleMoveTask set a PendingMove
|
||||
// pointing at "In Progress" and queued the hand-off prompt.
|
||||
// - QA's turn ends → agent.ready fires → handleAgentReady is invoked.
|
||||
//
|
||||
// Expected outcome:
|
||||
// - Task workflow_step_id == "In Progress" step ID.
|
||||
// - The "In Progress" session is the primary (revived from COMPLETED).
|
||||
// - The "In Review" session is COMPLETED.
|
||||
// - No subsequent transition fires.
|
||||
//
|
||||
// The test deliberately stubs PromptAgent / LaunchAgent so we don't need a real
|
||||
// agent process. The bug we're chasing is in the orchestrator's transition
|
||||
// logic, not in the executor — so an executor that returns success deterministically
|
||||
// is sufficient to expose multiple transitions if they occur.
|
||||
func TestPendingMove_ReviewToInProgress_OneTransitionOnly(t *testing.T) {
|
||||
sc := buildPendingMoveScenario(t)
|
||||
|
||||
// Snapshot the workflow_step_id history by sampling at intervals. We expect
|
||||
// exactly one change: stepInReviewID → stepInProgressID. Anything else
|
||||
// (e.g. stepInProgressID → stepInReviewID right after, or skipping ahead
|
||||
// to stepReviewedID) means the bug has fired.
|
||||
historyDone, stepHistory := sc.startStepHistorySampler(t, 2*time.Second)
|
||||
|
||||
// Fire the QA session's agent.ready — this is what handleAgentReady receives
|
||||
// when MarkReady is called from handleCompleteEventMarkState after the QA
|
||||
// agent's turn ends.
|
||||
sc.svc.handleAgentReady(sc.ctx, watcher.AgentEventData{
|
||||
TaskID: "task-1",
|
||||
SessionID: sc.reviewSessionID,
|
||||
AgentExecutionID: "ae-review",
|
||||
AgentProfileID: profileReview,
|
||||
})
|
||||
|
||||
// Give the async processStepExitAndEnter goroutine time to complete.
|
||||
// Then drain the history collector.
|
||||
time.Sleep(1 * time.Second)
|
||||
<-historyDone
|
||||
|
||||
sc.assertOneTransitionToInProgress(t, *stepHistory)
|
||||
}
|
||||
|
||||
// --- Pending-move scenario builder & assertions ---
|
||||
|
||||
const (
|
||||
stepInProgressID = "step-in-progress"
|
||||
stepInReviewID = "step-in-review"
|
||||
stepReviewedID = "step-reviewed"
|
||||
|
||||
profileImpl = "profile-impl"
|
||||
profileReview = "profile-review"
|
||||
)
|
||||
|
||||
// pendingMoveScenario is the seeded fixture used by deferred-move tests.
|
||||
// It owns the repo + service + mock agent manager so a single value carries
|
||||
// every reference an assertion needs without long parameter lists.
|
||||
type pendingMoveScenario struct {
|
||||
ctx context.Context
|
||||
svc *Service
|
||||
repo *sqliterepo.Repository
|
||||
agentMgr *mockAgentManager
|
||||
stepGetter *mockStepGetter
|
||||
implSessionID string
|
||||
reviewSessionID string
|
||||
implRelaunchExec string
|
||||
}
|
||||
|
||||
// buildPendingMoveScenario sets up the full repro scenario:
|
||||
// - 3 workflow steps: In Progress (auto_start, on_turn_complete → Review),
|
||||
// In Review (auto_start, on_turn_complete → Reviewed), Reviewed (terminal).
|
||||
// - Task currently at "In Review", with two sessions: an Impl session that
|
||||
// was completed earlier (revivable — has executors_running), and a Review
|
||||
// session that's currently RUNNING and primary.
|
||||
// - PendingMove + hand-off prompt seeded as if the QA agent just called
|
||||
// move_task_kandev mid-turn.
|
||||
// - Mock LaunchAgent that fires the boot signal asynchronously so the
|
||||
// resume path can complete in tests without a real agent process.
|
||||
func buildPendingMoveScenario(t *testing.T) *pendingMoveScenario {
|
||||
t.Helper()
|
||||
ctx := context.Background()
|
||||
now := time.Now().UTC()
|
||||
|
||||
repo := setupTestRepo(t)
|
||||
if err := repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws1", Name: "Test", CreatedAt: now, UpdatedAt: now}); err != nil {
|
||||
t.Fatalf("create workspace: %v", err)
|
||||
}
|
||||
if err := repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf1", WorkspaceID: "ws1", Name: "Test WF", CreatedAt: now, UpdatedAt: now}); err != nil {
|
||||
t.Fatalf("create workflow: %v", err)
|
||||
}
|
||||
|
||||
stepGetter := newPendingMoveStepGetter()
|
||||
|
||||
if err := repo.CreateTask(ctx, &models.Task{
|
||||
ID: "task-1", WorkflowID: "wf1", WorkflowStepID: stepInReviewID,
|
||||
Title: "Test", Description: "Implement a python buggy fibonnacci",
|
||||
State: v1.TaskStateInProgress, CreatedAt: now, UpdatedAt: now,
|
||||
}); err != nil {
|
||||
t.Fatalf("create task: %v", err)
|
||||
}
|
||||
|
||||
implSessionID := seedImplSession(t, repo, now)
|
||||
reviewSessionID := seedReviewSession(t, repo, now)
|
||||
|
||||
taskRepo := newMockTaskRepo()
|
||||
taskRepo.tasks["task-1"] = &v1.Task{
|
||||
ID: "task-1", WorkspaceID: "ws1", WorkflowID: "wf1",
|
||||
Title: "Test", Description: "Implement a python buggy fibonnacci",
|
||||
State: v1.TaskStateInProgress,
|
||||
}
|
||||
|
||||
agentMgr := &mockAgentManager{}
|
||||
log := testLogger()
|
||||
exec := executor.NewExecutor(agentMgr, repo, log, executor.ExecutorConfig{})
|
||||
sched := scheduler.NewScheduler(queue.NewTaskQueue(100), exec, taskRepo, log, scheduler.SchedulerConfig{})
|
||||
|
||||
svc := &Service{
|
||||
logger: log,
|
||||
repo: repo,
|
||||
workflowStepGetter: stepGetter,
|
||||
taskRepo: taskRepo,
|
||||
agentManager: agentMgr,
|
||||
messageQueue: messagequeue.NewService(log),
|
||||
executor: exec,
|
||||
scheduler: sched,
|
||||
}
|
||||
svc.SetWorkflowStepGetter(stepGetter)
|
||||
|
||||
const implRelaunchExec = "ae-impl-relaunch"
|
||||
wireBootReadySimulator(svc, agentMgr, implRelaunchExec)
|
||||
|
||||
const handoffPrompt = "You were moved to this step with the following message: " +
|
||||
"The file fibonacci.py has two bugs — fix them."
|
||||
if _, err := svc.messageQueue.QueueMessage(
|
||||
ctx, reviewSessionID, "task-1", handoffPrompt, "", "mcp-move-task", false, nil,
|
||||
); err != nil {
|
||||
t.Fatalf("queue hand-off prompt: %v", err)
|
||||
}
|
||||
svc.messageQueue.SetPendingMove(ctx, reviewSessionID, &messagequeue.PendingMove{
|
||||
TaskID: "task-1",
|
||||
WorkflowID: "wf1",
|
||||
WorkflowStepID: stepInProgressID,
|
||||
})
|
||||
|
||||
return &pendingMoveScenario{
|
||||
ctx: ctx,
|
||||
svc: svc,
|
||||
repo: repo,
|
||||
agentMgr: agentMgr,
|
||||
stepGetter: stepGetter,
|
||||
implSessionID: implSessionID,
|
||||
reviewSessionID: reviewSessionID,
|
||||
implRelaunchExec: implRelaunchExec,
|
||||
}
|
||||
}
|
||||
|
||||
// newPendingMoveStepGetter builds the 3-step workflow used by the scenario.
|
||||
// Both auto_start steps have UNCONDITIONAL on_turn_complete rules — that's
|
||||
// the workflow shape that exposed the original ping-pong bug, so we keep it.
|
||||
func newPendingMoveStepGetter() *mockStepGetter {
|
||||
sg := newMockStepGetter()
|
||||
sg.steps[stepInProgressID] = &wfmodels.WorkflowStep{
|
||||
ID: stepInProgressID, WorkflowID: "wf1", Name: "In Progress", Position: 1,
|
||||
AgentProfileID: profileImpl,
|
||||
Events: wfmodels.StepEvents{
|
||||
OnEnter: []wfmodels.OnEnterAction{{Type: wfmodels.OnEnterAutoStartAgent}},
|
||||
OnTurnComplete: []wfmodels.OnTurnCompleteAction{
|
||||
{Type: wfmodels.OnTurnCompleteMoveToStep, Config: map[string]interface{}{"step_id": stepInReviewID}},
|
||||
},
|
||||
},
|
||||
}
|
||||
sg.steps[stepInReviewID] = &wfmodels.WorkflowStep{
|
||||
ID: stepInReviewID, WorkflowID: "wf1", Name: "In Review", Position: 2,
|
||||
AgentProfileID: profileReview,
|
||||
Events: wfmodels.StepEvents{
|
||||
OnEnter: []wfmodels.OnEnterAction{{Type: wfmodels.OnEnterAutoStartAgent}},
|
||||
OnTurnComplete: []wfmodels.OnTurnCompleteAction{
|
||||
{Type: wfmodels.OnTurnCompleteMoveToStep, Config: map[string]interface{}{"step_id": stepReviewedID}},
|
||||
},
|
||||
},
|
||||
}
|
||||
sg.steps[stepReviewedID] = &wfmodels.WorkflowStep{
|
||||
ID: stepReviewedID, WorkflowID: "wf1", Name: "Reviewed", Position: 3,
|
||||
}
|
||||
return sg
|
||||
}
|
||||
|
||||
// seedImplSession seeds the previously-completed Impl session with an
|
||||
// executors_running record so reuseSessionForStep revives it as
|
||||
// WAITING_FOR_INPUT (matching the real-world "previously launched" path).
|
||||
func seedImplSession(t *testing.T, repo *sqliterepo.Repository, now time.Time) string {
|
||||
t.Helper()
|
||||
const id = "session-impl"
|
||||
completedAt := now.Add(-1 * time.Minute)
|
||||
sess := &models.TaskSession{
|
||||
ID: id,
|
||||
TaskID: "task-1",
|
||||
AgentProfileID: profileImpl,
|
||||
ExecutorID: "exec-local",
|
||||
ExecutorProfileID: "ep1",
|
||||
AgentExecutionID: "ae-impl-original",
|
||||
State: models.TaskSessionStateCompleted,
|
||||
CompletedAt: &completedAt,
|
||||
StartedAt: now.Add(-2 * time.Minute),
|
||||
UpdatedAt: completedAt,
|
||||
}
|
||||
if err := repo.CreateTaskSession(context.Background(), sess); err != nil {
|
||||
t.Fatalf("create impl session: %v", err)
|
||||
}
|
||||
if err := repo.UpsertExecutorRunning(context.Background(), &models.ExecutorRunning{
|
||||
ID: id, SessionID: id, TaskID: "task-1",
|
||||
ResumeToken: "resume-token-impl", AgentExecutionID: "ae-impl-original",
|
||||
CreatedAt: now.Add(-2 * time.Minute), UpdatedAt: completedAt,
|
||||
}); err != nil {
|
||||
t.Fatalf("upsert executors_running for impl: %v", err)
|
||||
}
|
||||
return id
|
||||
}
|
||||
|
||||
// seedReviewSession seeds the currently-active Review session as primary,
|
||||
// RUNNING — the QA agent that's about to fire its move_task_kandev call.
|
||||
func seedReviewSession(t *testing.T, repo *sqliterepo.Repository, now time.Time) string {
|
||||
t.Helper()
|
||||
const id = "session-review"
|
||||
sess := &models.TaskSession{
|
||||
ID: id,
|
||||
TaskID: "task-1",
|
||||
AgentProfileID: profileReview,
|
||||
ExecutorID: "exec-local",
|
||||
ExecutorProfileID: "ep1",
|
||||
AgentExecutionID: "ae-review",
|
||||
State: models.TaskSessionStateRunning,
|
||||
IsPrimary: true,
|
||||
StartedAt: now,
|
||||
UpdatedAt: now,
|
||||
}
|
||||
if err := repo.CreateTaskSession(context.Background(), sess); err != nil {
|
||||
t.Fatalf("create review session: %v", err)
|
||||
}
|
||||
return id
|
||||
}
|
||||
|
||||
// wireBootReadySimulator stubs LaunchAgent to fire handleAgentBootReady ~50ms
|
||||
// after returning. Real agentctl bootstrap publishes events.AgentBootReady from
|
||||
// outside the LaunchAgent call; mirroring that timing here lets the resume
|
||||
// path complete in unit tests without spawning a real subprocess.
|
||||
func wireBootReadySimulator(svc *Service, agentMgr *mockAgentManager, newExecID string) {
|
||||
agentMgr.launchAgentFunc = func(_ context.Context, req *executor.LaunchAgentRequest) (*executor.LaunchAgentResponse, error) {
|
||||
go func() {
|
||||
time.Sleep(50 * time.Millisecond)
|
||||
svc.handleAgentBootReady(context.Background(), watcher.AgentEventData{
|
||||
TaskID: req.TaskID,
|
||||
SessionID: req.SessionID,
|
||||
AgentExecutionID: newExecID,
|
||||
AgentProfileID: req.AgentProfileID,
|
||||
})
|
||||
}()
|
||||
return &executor.LaunchAgentResponse{
|
||||
AgentExecutionID: newExecID,
|
||||
ContainerID: "container-relaunch",
|
||||
Status: v1.AgentStatusReady,
|
||||
}, nil
|
||||
}
|
||||
}
|
||||
|
||||
// startStepHistorySampler polls task.WorkflowStepID and appends every change
|
||||
// to a slice. Returned channel closes when sampling ends; the *[]string is
|
||||
// safe to read from the caller after that.
|
||||
func (sc *pendingMoveScenario) startStepHistorySampler(t *testing.T, duration time.Duration) (<-chan struct{}, *[]string) {
|
||||
t.Helper()
|
||||
done := make(chan struct{})
|
||||
history := []string{stepInReviewID}
|
||||
go func() {
|
||||
defer close(done)
|
||||
seen := stepInReviewID
|
||||
deadline := time.Now().Add(duration)
|
||||
for time.Now().Before(deadline) {
|
||||
task, err := sc.repo.GetTask(sc.ctx, "task-1")
|
||||
if err == nil && task.WorkflowStepID != seen {
|
||||
seen = task.WorkflowStepID
|
||||
history = append(history, seen)
|
||||
}
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
}
|
||||
}()
|
||||
return done, &history
|
||||
}
|
||||
|
||||
// assertOneTransitionToInProgress checks every postcondition of the scenario:
|
||||
// task moved to In Progress, exactly one transition, sessions in the right
|
||||
// state, and the hand-off prompt landed on the impl session (delivered or
|
||||
// queued — either is acceptable for this regression).
|
||||
func (sc *pendingMoveScenario) assertOneTransitionToInProgress(t *testing.T, stepHistory []string) {
|
||||
t.Helper()
|
||||
|
||||
finalTask, err := sc.repo.GetTask(sc.ctx, "task-1")
|
||||
if err != nil {
|
||||
t.Fatalf("load final task: %v", err)
|
||||
}
|
||||
|
||||
dedup := dedupConsecutive(stepHistory)
|
||||
t.Logf("workflow_step_id transition history: %v", stepNamesFromIDs(dedup, sc.stepGetter))
|
||||
|
||||
if finalTask.WorkflowStepID != stepInProgressID {
|
||||
t.Errorf("final workflow_step_id = %q, want %q (In Progress)", finalTask.WorkflowStepID, stepInProgressID)
|
||||
}
|
||||
|
||||
expected := []string{stepInReviewID, stepInProgressID}
|
||||
if !sliceEqual(dedup, expected) {
|
||||
t.Errorf("transition history = %v, want %v\n (this means the deferred-move triggered spurious additional transitions — the bug)",
|
||||
stepNamesFromIDs(dedup, sc.stepGetter), stepNamesFromIDs(expected, sc.stepGetter))
|
||||
}
|
||||
|
||||
rev, err := sc.repo.GetTaskSession(sc.ctx, sc.reviewSessionID)
|
||||
if err != nil {
|
||||
t.Fatalf("load review session: %v", err)
|
||||
}
|
||||
if rev.State != models.TaskSessionStateCompleted {
|
||||
t.Errorf("review session state = %q, want COMPLETED (parked by the profile switch)", rev.State)
|
||||
}
|
||||
if rev.IsPrimary {
|
||||
t.Error("review session must no longer be primary (the impl session takes over)")
|
||||
}
|
||||
|
||||
impl, err := sc.repo.GetTaskSession(sc.ctx, sc.implSessionID)
|
||||
if err != nil {
|
||||
t.Fatalf("load impl session: %v", err)
|
||||
}
|
||||
if !impl.IsPrimary {
|
||||
t.Error("impl session must be primary after the deferred move applies")
|
||||
}
|
||||
if impl.State == models.TaskSessionStateCompleted {
|
||||
t.Errorf("impl session state = %q, expected non-terminal (revived for a new turn)", impl.State)
|
||||
}
|
||||
|
||||
sc.assertHandoffDeliveredOrQueued(t)
|
||||
}
|
||||
|
||||
// assertHandoffDeliveredOrQueued checks the hand-off prompt landed on the impl
|
||||
// session — either delivered to its agent (PromptAgent capture) or sitting in
|
||||
// the queue waiting for delivery. Both are acceptable; the failure mode the
|
||||
// regression catches is "lost" (neither delivered nor queued) or "delivered
|
||||
// to the wrong session".
|
||||
func (sc *pendingMoveScenario) assertHandoffDeliveredOrQueued(t *testing.T) {
|
||||
t.Helper()
|
||||
implPrompts := capturedPromptsForExecution(sc.agentMgr, sc.implRelaunchExec)
|
||||
implQueued := sc.svc.messageQueue.GetStatus(sc.ctx, sc.implSessionID)
|
||||
|
||||
if len(implPrompts) == 0 && !implQueued.IsQueued {
|
||||
t.Error("hand-off prompt was neither delivered to the impl session nor queued for it")
|
||||
return
|
||||
}
|
||||
for _, p := range implPrompts {
|
||||
if strings.Contains(p, "fibonacci.py has two bugs") {
|
||||
return
|
||||
}
|
||||
}
|
||||
if implQueued.IsQueued && implQueued.Message != nil &&
|
||||
strings.Contains(implQueued.Message.Content, "fibonacci.py has two bugs") {
|
||||
return
|
||||
}
|
||||
t.Errorf("hand-off prompt was neither delivered nor queued with the expected content")
|
||||
}
|
||||
|
||||
// --- Helpers ---
|
||||
|
||||
// capturedPromptsForExecution returns only the prompts that were sent to the
|
||||
// given agent execution ID. The earlier version ignored its selector and
|
||||
// returned every recorded prompt — which would let the test pass even if the
|
||||
// hand-off had been delivered to the wrong session.
|
||||
func capturedPromptsForExecution(agentMgr *mockAgentManager, executionID string) []string {
|
||||
agentMgr.mu.Lock()
|
||||
defer agentMgr.mu.Unlock()
|
||||
out := make([]string, 0, len(agentMgr.capturedPromptCalls))
|
||||
for _, c := range agentMgr.capturedPromptCalls {
|
||||
if c.ExecutionID == executionID {
|
||||
out = append(out, c.Prompt)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func dedupConsecutive(in []string) []string {
|
||||
if len(in) == 0 {
|
||||
return in
|
||||
}
|
||||
out := []string{in[0]}
|
||||
for i := 1; i < len(in); i++ {
|
||||
if in[i] != in[i-1] {
|
||||
out = append(out, in[i])
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func sliceEqual(a, b []string) bool {
|
||||
if len(a) != len(b) {
|
||||
return false
|
||||
}
|
||||
for i := range a {
|
||||
if a[i] != b[i] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func stepNamesFromIDs(ids []string, sg *mockStepGetter) []string {
|
||||
out := make([]string, 0, len(ids))
|
||||
for _, id := range ids {
|
||||
if step, ok := sg.steps[id]; ok {
|
||||
out = append(out, step.Name)
|
||||
} else {
|
||||
out = append(out, id)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// TestHandleAgentBootReady_DoesNotTriggerOnTurnComplete locks in the post-fix
|
||||
// invariant: a boot-ready signal (agent's ACP session has just initialized,
|
||||
// no turn has run yet) must NEVER step the workflow. The lifecycle layer now
|
||||
// publishes events.AgentBootReady — distinct from events.AgentReady — and the
|
||||
// orchestrator routes it to handleAgentBootReady which only flips the session
|
||||
// to WAITING_FOR_INPUT.
|
||||
//
|
||||
// Before this split, both signals shared events.AgentReady and the
|
||||
// orchestrator tried to disambiguate them with the resumeInProgressSessions
|
||||
// flag. That flag had a race: when the boot ready arrived BEFORE
|
||||
// persistResumeState wrote state=STARTING, handleAgentReady's state guard
|
||||
// returned without consuming the flag, leaking it to the next event and
|
||||
// firing on_turn_complete against the wrong session.
|
||||
//
|
||||
// This test fires the boot signal directly into handleAgentBootReady to
|
||||
// confirm: (a) no on_turn_complete evaluation runs, (b) the session ends up
|
||||
// WAITING_FOR_INPUT regardless of what state it was in.
|
||||
func TestHandleAgentBootReady_DoesNotTriggerOnTurnComplete(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
now := time.Now().UTC()
|
||||
|
||||
repo := setupTestRepo(t)
|
||||
if err := repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws1", Name: "Test", CreatedAt: now, UpdatedAt: now}); err != nil {
|
||||
t.Fatalf("create workspace: %v", err)
|
||||
}
|
||||
if err := repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf1", WorkspaceID: "ws1", Name: "WF", CreatedAt: now, UpdatedAt: now}); err != nil {
|
||||
t.Fatalf("create workflow: %v", err)
|
||||
}
|
||||
|
||||
// One step with an unconditional on_turn_complete. If a boot-ready
|
||||
// somehow reaches the turn-end path, this rule fires and the task moves —
|
||||
// the user-visible symptom of the original bug.
|
||||
stepGetter := newMockStepGetter()
|
||||
stepGetter.steps["step-current"] = &wfmodels.WorkflowStep{
|
||||
ID: "step-current", WorkflowID: "wf1", Name: "Current", Position: 1,
|
||||
Events: wfmodels.StepEvents{
|
||||
OnTurnComplete: []wfmodels.OnTurnCompleteAction{
|
||||
{Type: wfmodels.OnTurnCompleteMoveToStep, Config: map[string]interface{}{"step_id": "step-next"}},
|
||||
},
|
||||
},
|
||||
}
|
||||
stepGetter.steps["step-next"] = &wfmodels.WorkflowStep{
|
||||
ID: "step-next", WorkflowID: "wf1", Name: "Next", Position: 2,
|
||||
}
|
||||
|
||||
if err := repo.CreateTask(ctx, &models.Task{
|
||||
ID: "task-1", WorkflowID: "wf1", WorkflowStepID: "step-current",
|
||||
Title: "T", Description: "D", State: v1.TaskStateInProgress,
|
||||
CreatedAt: now, UpdatedAt: now,
|
||||
}); err != nil {
|
||||
t.Fatalf("create task: %v", err)
|
||||
}
|
||||
|
||||
// Two scenarios the boot signal must handle correctly:
|
||||
// - state=STARTING (the textbook case: persistResumeState wrote it)
|
||||
// - state=WAITING_FOR_INPUT (the racy case: boot signal beat
|
||||
// persistResumeState, or reviveReusedSession left it WAITING)
|
||||
cases := []struct {
|
||||
name string
|
||||
startSt models.TaskSessionState
|
||||
expectSt models.TaskSessionState
|
||||
}{
|
||||
{"STARTING", models.TaskSessionStateStarting, models.TaskSessionStateWaitingForInput},
|
||||
{"WAITING_FOR_INPUT (race-with-persistResumeState)", models.TaskSessionStateWaitingForInput, models.TaskSessionStateWaitingForInput},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
sessionID := "s1-" + tc.name
|
||||
if err := repo.CreateTaskSession(ctx, &models.TaskSession{
|
||||
ID: sessionID, TaskID: "task-1", AgentProfileID: "profile-impl",
|
||||
AgentExecutionID: "ae-current",
|
||||
State: tc.startSt,
|
||||
IsPrimary: true,
|
||||
StartedAt: now, UpdatedAt: now,
|
||||
}); err != nil {
|
||||
t.Fatalf("create session: %v", err)
|
||||
}
|
||||
|
||||
taskRepo := newMockTaskRepo()
|
||||
taskRepo.tasks["task-1"] = &v1.Task{
|
||||
ID: "task-1", WorkflowID: "wf1", State: v1.TaskStateInProgress,
|
||||
}
|
||||
|
||||
agentMgr := &mockAgentManager{}
|
||||
log := testLogger()
|
||||
exec := executor.NewExecutor(agentMgr, repo, log, executor.ExecutorConfig{})
|
||||
svc := &Service{
|
||||
logger: log,
|
||||
repo: repo,
|
||||
workflowStepGetter: stepGetter,
|
||||
taskRepo: taskRepo,
|
||||
agentManager: agentMgr,
|
||||
messageQueue: messagequeue.NewService(log),
|
||||
executor: exec,
|
||||
}
|
||||
svc.SetWorkflowStepGetter(stepGetter)
|
||||
|
||||
// Reset task to step-current in case a prior subtest moved it.
|
||||
tk, _ := repo.GetTask(ctx, "task-1")
|
||||
tk.WorkflowStepID = "step-current"
|
||||
_ = repo.UpdateTask(ctx, tk)
|
||||
|
||||
// Fire the new boot-only event. The handler must NOT run on_turn_complete.
|
||||
svc.handleAgentBootReady(ctx, watcher.AgentEventData{
|
||||
TaskID: "task-1", SessionID: sessionID,
|
||||
AgentExecutionID: "ae-current",
|
||||
AgentProfileID: "profile-impl",
|
||||
})
|
||||
|
||||
finalTask, err := repo.GetTask(ctx, "task-1")
|
||||
if err != nil {
|
||||
t.Fatalf("load task: %v", err)
|
||||
}
|
||||
if finalTask.WorkflowStepID != "step-current" {
|
||||
t.Errorf("workflow_step_id = %q, want %q (boot signal must not move the workflow)",
|
||||
finalTask.WorkflowStepID, "step-current")
|
||||
}
|
||||
|
||||
finalSess, err := repo.GetTaskSession(ctx, sessionID)
|
||||
if err != nil {
|
||||
t.Fatalf("load session: %v", err)
|
||||
}
|
||||
if finalSess.State != tc.expectSt {
|
||||
t.Errorf("session.State = %q, want %q", finalSess.State, tc.expectSt)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -126,8 +126,11 @@ type mockAgentManager struct {
|
||||
mu sync.Mutex
|
||||
stopAgentWithReasonArgs []stopAgentCall // tracks StopAgentWithReason calls
|
||||
|
||||
// Prompt tracking
|
||||
capturedPrompts []string // tracks prompts passed to PromptAgent
|
||||
// Prompt tracking — capturedPrompts records prompts only (legacy, several
|
||||
// tests assert on it directly). capturedPromptCalls records the same with
|
||||
// the execution ID so callers can filter by the agent that received it.
|
||||
capturedPrompts []string
|
||||
capturedPromptCalls []promptCall
|
||||
// Optional: closed once on the first PromptAgent call so tests can wait
|
||||
// deterministically without polling. Tests opt in by initializing the channel.
|
||||
promptDone chan struct{}
|
||||
@@ -148,6 +151,12 @@ type stopAgentCall struct {
|
||||
Force bool
|
||||
}
|
||||
|
||||
// promptCall records one PromptAgent invocation with its target execution ID.
|
||||
type promptCall struct {
|
||||
ExecutionID string
|
||||
Prompt string
|
||||
}
|
||||
|
||||
type passthroughStdinCall struct {
|
||||
SessionID string
|
||||
Data string
|
||||
@@ -171,10 +180,11 @@ func (m *mockAgentManager) StopAgentWithReason(_ context.Context, agentExecution
|
||||
})
|
||||
return nil
|
||||
}
|
||||
func (m *mockAgentManager) PromptAgent(_ context.Context, _ string, prompt string, _ []v1.MessageAttachment) (*executor.PromptResult, error) {
|
||||
func (m *mockAgentManager) PromptAgent(_ context.Context, executionID string, prompt string, _ []v1.MessageAttachment) (*executor.PromptResult, error) {
|
||||
m.mu.Lock()
|
||||
first := len(m.capturedPrompts) == 0
|
||||
m.capturedPrompts = append(m.capturedPrompts, prompt)
|
||||
m.capturedPromptCalls = append(m.capturedPromptCalls, promptCall{ExecutionID: executionID, Prompt: prompt})
|
||||
promptErr := m.promptErr
|
||||
promptResult := m.promptResult
|
||||
doneCh := m.promptDone
|
||||
|
||||
@@ -2,6 +2,7 @@ package orchestrator
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
@@ -9,6 +10,7 @@ import (
|
||||
|
||||
"github.com/kandev/kandev/internal/events"
|
||||
"github.com/kandev/kandev/internal/events/bus"
|
||||
"github.com/kandev/kandev/internal/orchestrator/executor"
|
||||
"github.com/kandev/kandev/internal/orchestrator/messagequeue"
|
||||
"github.com/kandev/kandev/internal/orchestrator/watcher"
|
||||
"github.com/kandev/kandev/internal/task/models"
|
||||
@@ -458,10 +460,11 @@ func (s *Service) resolveStepAgentProfile(ctx context.Context, step *wfmodels.Wo
|
||||
return ""
|
||||
}
|
||||
|
||||
// switchSessionForStep stops the current session and creates a new one with a different agent profile.
|
||||
// Returns the new session, or nil + error if the switch fails.
|
||||
// The new session is prepared BEFORE completing the old one: if PrepareSession fails, the old
|
||||
// session remains active and the task stays recoverable.
|
||||
// switchSessionForStep activates a session for the new agent profile.
|
||||
// If an existing session on this task already uses the target profile it is
|
||||
// reused (re-promoted to primary, brought out of COMPLETED if it had been
|
||||
// switched away from previously). Otherwise a new session is prepared.
|
||||
// In both cases the previous session is stopped and marked COMPLETED.
|
||||
func (s *Service) switchSessionForStep(ctx context.Context, taskID string, currentSession *models.TaskSession, newAgentProfileID string) (*models.TaskSession, error) {
|
||||
s.logger.Info("switching session for workflow step agent profile change",
|
||||
zap.String("task_id", taskID),
|
||||
@@ -475,6 +478,129 @@ func (s *Service) switchSessionForStep(ctx context.Context, taskID string, curre
|
||||
zap.String("task_id", taskID), zap.Error(err))
|
||||
}
|
||||
|
||||
existing, lookupErr := s.findReusableSessionForProfile(ctx, taskID, newAgentProfileID, currentSession.ID)
|
||||
if lookupErr != nil {
|
||||
s.logger.Warn("failed to look up reusable session, falling through to create new",
|
||||
zap.String("task_id", taskID),
|
||||
zap.String("agent_profile_id", newAgentProfileID),
|
||||
zap.Error(lookupErr))
|
||||
}
|
||||
if existing != nil {
|
||||
return s.reuseSessionForStep(ctx, taskID, currentSession, existing)
|
||||
}
|
||||
|
||||
return s.createNewSessionForStep(ctx, taskID, currentSession, newAgentProfileID)
|
||||
}
|
||||
|
||||
// findReusableSessionForProfile returns the most-recently-updated session on
|
||||
// this task that uses the target profile (and is not the session being
|
||||
// switched away from), or nil if none exists. Failed/cancelled sessions are
|
||||
// excluded — those are dead and shouldn't be revived implicitly.
|
||||
func (s *Service) findReusableSessionForProfile(ctx context.Context, taskID, profileID, excludeSessionID string) (*models.TaskSession, error) {
|
||||
if profileID == "" {
|
||||
return nil, nil
|
||||
}
|
||||
sessions, err := s.repo.ListTaskSessions(ctx, taskID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var best *models.TaskSession
|
||||
for _, sess := range sessions {
|
||||
if sess.ID == excludeSessionID {
|
||||
continue
|
||||
}
|
||||
if sess.AgentProfileID != profileID {
|
||||
continue
|
||||
}
|
||||
// Skip user-cancelled sessions — those are explicit stops and
|
||||
// shouldn't be auto-revived. FAILED sessions are reused (the failure
|
||||
// may have been transient; either way the user expects "one session
|
||||
// per profile per task" so we revive rather than orphan a duplicate).
|
||||
if sess.State == models.TaskSessionStateCancelled {
|
||||
continue
|
||||
}
|
||||
if best == nil || sess.UpdatedAt.After(best.UpdatedAt) {
|
||||
best = sess
|
||||
}
|
||||
}
|
||||
return best, nil
|
||||
}
|
||||
|
||||
// reuseSessionForStep promotes an existing session to primary, brings it out
|
||||
// of COMPLETED/FAILED if needed, and stops + completes the previous session.
|
||||
// The agent for the reused session is not relaunched here — when a prompt
|
||||
// arrives, the autoStart/PromptTask paths handle the launch.
|
||||
//
|
||||
// Previously-launched sessions (executors_running record exists, has resume
|
||||
// token) are flipped to WAITING_FOR_INPUT so PromptTask's ensureSessionRunning
|
||||
// lazy-resumes them via ResumeSession.
|
||||
//
|
||||
// Never-launched sessions (e.g. PrepareSession created the row but the
|
||||
// workflow switched away before the agent started) have no executors_running
|
||||
// record. They go to CREATED so autoStartStepPrompt routes through
|
||||
// StartCreatedSession → LaunchPreparedSession (a full fresh launch).
|
||||
func (s *Service) reuseSessionForStep(ctx context.Context, taskID string, currentSession, existing *models.TaskSession) (*models.TaskSession, error) {
|
||||
s.logger.Info("reusing existing session for profile",
|
||||
zap.String("task_id", taskID),
|
||||
zap.String("current_session", currentSession.ID),
|
||||
zap.String("reused_session", existing.ID),
|
||||
zap.String("reused_profile", existing.AgentProfileID),
|
||||
zap.String("reused_state", string(existing.State)))
|
||||
|
||||
if existing.State == models.TaskSessionStateCompleted || existing.State == models.TaskSessionStateFailed {
|
||||
s.reviveReusedSession(ctx, existing)
|
||||
}
|
||||
|
||||
if err := s.SetPrimarySession(ctx, existing.ID); err != nil {
|
||||
s.logger.Warn("failed to set reused session as primary",
|
||||
zap.String("session_id", existing.ID), zap.Error(err))
|
||||
}
|
||||
|
||||
// Transfer any queued message and pending move from the session being
|
||||
// switched away from to the reused session — without this, a hand-off
|
||||
// prompt queued via move_task_kandev on the previous session is orphaned
|
||||
// and gets delivered to the wrong agent the next time that previous
|
||||
// session is reused (e.g. on the on_turn_complete bounce back).
|
||||
if s.messageQueue != nil {
|
||||
s.messageQueue.TransferSession(ctx, currentSession.ID, existing.ID)
|
||||
}
|
||||
|
||||
s.completeAndStopSession(ctx, taskID, currentSession)
|
||||
return existing, nil
|
||||
}
|
||||
|
||||
// reviveReusedSession flips a terminal (COMPLETED/FAILED) session back to a
|
||||
// state where the downstream autoStart/PromptTask paths can launch its agent.
|
||||
// The target state depends on whether the session was ever launched:
|
||||
// - Has executors_running record → WAITING_FOR_INPUT, lazy-resume from token
|
||||
// - No record → CREATED, fresh launch via StartCreatedSession
|
||||
//
|
||||
// The previous error message (from a prior FAILED state) is cleared so the
|
||||
// frontend stops surfacing stale red banners on a now-active session.
|
||||
func (s *Service) reviveReusedSession(ctx context.Context, session *models.TaskSession) {
|
||||
wasLaunched := false
|
||||
if running, err := s.repo.GetExecutorRunningBySessionID(ctx, session.ID); err == nil && running != nil {
|
||||
wasLaunched = true
|
||||
}
|
||||
if wasLaunched {
|
||||
session.State = models.TaskSessionStateWaitingForInput
|
||||
} else {
|
||||
session.State = models.TaskSessionStateCreated
|
||||
}
|
||||
session.CompletedAt = nil
|
||||
session.ErrorMessage = ""
|
||||
session.UpdatedAt = time.Now().UTC()
|
||||
if err := s.repo.UpdateTaskSession(ctx, session); err != nil {
|
||||
s.logger.Warn("failed to revive reused session out of COMPLETED",
|
||||
zap.String("session_id", session.ID),
|
||||
zap.String("target_state", string(session.State)),
|
||||
zap.Error(err))
|
||||
}
|
||||
}
|
||||
|
||||
// createNewSessionForStep is the original switch-and-create-fresh-session path,
|
||||
// used when there is no existing session for the target profile.
|
||||
func (s *Service) createNewSessionForStep(ctx context.Context, taskID string, currentSession *models.TaskSession, newAgentProfileID string) (*models.TaskSession, error) {
|
||||
// Prepare the new session BEFORE touching the old one.
|
||||
// If any step below fails, the old session remains active and the task stays recoverable.
|
||||
task, err := s.scheduler.GetTask(ctx, taskID)
|
||||
@@ -514,6 +640,13 @@ func (s *Service) switchSessionForStep(ctx context.Context, taskID string, curre
|
||||
}
|
||||
}
|
||||
|
||||
// Transfer any queued message (e.g. a move_task_kandev hand-off prompt) and
|
||||
// pending move from the old session to the new one — the queue is keyed by
|
||||
// session ID, and without this the prompt would never reach the new agent.
|
||||
if s.messageQueue != nil {
|
||||
s.messageQueue.TransferSession(ctx, currentSession.ID, newSession.ID)
|
||||
}
|
||||
|
||||
// Promote the new session to primary so it's loaded when navigating back to this task.
|
||||
// Use SetPrimarySession (not repo.SetSessionPrimary) to broadcast a task.updated WS
|
||||
// event — the frontend reads primarySessionId from the task to render the star icon.
|
||||
@@ -522,34 +655,44 @@ func (s *Service) switchSessionForStep(ctx context.Context, taskID string, curre
|
||||
zap.String("session_id", newSession.ID), zap.Error(err))
|
||||
}
|
||||
|
||||
// New session is ready — now safe to stop the old agent and complete the old session.
|
||||
if currentSession.AgentExecutionID != "" {
|
||||
if err := s.agentManager.StopAgent(ctx, currentSession.AgentExecutionID, false); err != nil {
|
||||
s.completeAndStopSession(ctx, taskID, currentSession)
|
||||
return newSession, nil
|
||||
}
|
||||
|
||||
// completeAndStopSession stops the agent for a session and marks it COMPLETED.
|
||||
// Used by both the reuse path and the create-new path to terminate the
|
||||
// previous session in a uniform way. IsPrimary is cleared explicitly so the
|
||||
// full-row UpdateTaskSession write doesn't overwrite the SetPrimarySession
|
||||
// call the caller just made on the replacement session.
|
||||
func (s *Service) completeAndStopSession(ctx context.Context, taskID string, session *models.TaskSession) {
|
||||
// Flip state to COMPLETED *before* stopping the agent. StopAgent fires an
|
||||
// agent.completed event, and handleAgentCompleted's terminal-state guard
|
||||
// only short-circuits when the session is already in a terminal state. If
|
||||
// we stopped first, the event would fire while state is still RUNNING (or
|
||||
// WAITING_FOR_INPUT for the deferred-move flow), the guard would miss it,
|
||||
// and processOnTurnCompleteViaEngine would evaluate the *new* (already
|
||||
// transitioned) step's on_turn_complete — re-firing the very transition we
|
||||
// just performed and ping-ponging the task between steps.
|
||||
s.updateTaskSessionState(ctx, taskID, session.ID, models.TaskSessionStateCompleted, "", false)
|
||||
|
||||
if session.AgentExecutionID != "" {
|
||||
if err := s.agentManager.StopAgent(ctx, session.AgentExecutionID, false); err != nil {
|
||||
s.logger.Warn("failed to stop agent for session switch",
|
||||
zap.String("session_id", currentSession.ID),
|
||||
zap.String("session_id", session.ID),
|
||||
zap.Error(err))
|
||||
}
|
||||
}
|
||||
|
||||
// Mark the current session as completed.
|
||||
// Use updateTaskSessionState to publish a session.state_changed WS event so the
|
||||
// frontend learns the old session is terminal and can adopt the new one.
|
||||
s.updateTaskSessionState(ctx, taskID, currentSession.ID, models.TaskSessionStateCompleted, "", false)
|
||||
// Also set CompletedAt timestamp for bookkeeping (updateTaskSessionState only sets state).
|
||||
// Clear IsPrimary to avoid overwriting the SetPrimarySession call above when writing back.
|
||||
now := time.Now().UTC()
|
||||
currentSession.State = models.TaskSessionStateCompleted
|
||||
currentSession.IsPrimary = false
|
||||
currentSession.CompletedAt = &now
|
||||
currentSession.UpdatedAt = now
|
||||
if err := s.repo.UpdateTaskSession(ctx, currentSession); err != nil {
|
||||
// New session is already created; log but don't abort.
|
||||
session.State = models.TaskSessionStateCompleted
|
||||
session.IsPrimary = false
|
||||
session.CompletedAt = &now
|
||||
session.UpdatedAt = now
|
||||
if err := s.repo.UpdateTaskSession(ctx, session); err != nil {
|
||||
s.logger.Warn("failed to complete old session after switch",
|
||||
zap.String("session_id", currentSession.ID),
|
||||
zap.String("session_id", session.ID),
|
||||
zap.Error(err))
|
||||
}
|
||||
|
||||
return newSession, nil
|
||||
}
|
||||
|
||||
// maybySwitchSessionForProfile checks whether the step requires a different agent profile
|
||||
@@ -608,6 +751,14 @@ func (s *Service) processOnEnter(ctx context.Context, taskID string, session *mo
|
||||
hasPlanMode := s.resolveStepPlanMode(ctx, session, step, isPassthrough)
|
||||
|
||||
if len(step.Events.OnEnter) == 0 && !sessionSwitched {
|
||||
// Active-turn case (e.g. move_task_kandev mid-turn): the agent is still
|
||||
// running and will fire agent.ready when the turn ends. Don't flip state
|
||||
// to WAITING here — handleAgentReady's RUNNING/STARTING guard would then
|
||||
// silence the event and orphan the queue. handleAgentReady runs
|
||||
// on_turn_complete against the new step and drains the queue itself.
|
||||
if session.State == models.TaskSessionStateRunning || session.State == models.TaskSessionStateStarting {
|
||||
return
|
||||
}
|
||||
s.setSessionWaitingForInput(ctx, taskID, sessionID, session)
|
||||
s.publishSessionWaitingEvent(ctx, taskID, sessionID, step.ID, session)
|
||||
s.drainQueuedMessageAfterTransition(ctx, sessionID)
|
||||
@@ -702,6 +853,12 @@ func (s *Service) processOnEnter(ctx context.Context, taskID string, session *mo
|
||||
}()
|
||||
return
|
||||
}
|
||||
// Same active-turn guard as the no-on_enter branch above: if the agent
|
||||
// is still mid-turn, leave state alone so handleAgentReady can run on
|
||||
// turn end. See that branch for the full rationale.
|
||||
if session.State == models.TaskSessionStateRunning || session.State == models.TaskSessionStateStarting {
|
||||
return
|
||||
}
|
||||
s.setSessionWaitingForInput(ctx, taskID, sessionID, session)
|
||||
s.publishSessionWaitingEvent(ctx, taskID, sessionID, step.ID, session)
|
||||
// handleAgentReady early-returns when a workflow transition occurs (#677),
|
||||
@@ -713,6 +870,108 @@ func (s *Service) processOnEnter(ctx context.Context, taskID string, session *mo
|
||||
}
|
||||
}
|
||||
|
||||
// applyPendingMove applies a deferred move_task_kandev call now that the agent's
|
||||
// turn has ended. Synchronous: updates the task's step in the DB, runs on_exit
|
||||
// for the source step and on_enter for the target step. Bypasses
|
||||
// task.Service.MoveTask (and the task.moved event) so the orchestrator's async
|
||||
// task.moved handler doesn't run a second processStepExitAndEnter for the same
|
||||
// transition. The message queue is left intact — any user-supplied prompt
|
||||
// already queued by handleMoveTask is delivered by the on_enter path or by
|
||||
// drainQueuedMessageAfterTransition.
|
||||
func (s *Service) applyPendingMove(ctx context.Context, taskID, sessionID string, session *models.TaskSession, move *messagequeue.PendingMove) {
|
||||
// reinsertPendingMove restores the move so a future agent.ready can retry.
|
||||
// Used on early failure paths (load errors, config issues) where the state
|
||||
// hasn't been touched yet. NOT used after ApplyTransition has executed —
|
||||
// at that point the workflow has either advanced or is in a corrupted state
|
||||
// and re-attempting the move on the next turn would just re-trip the same
|
||||
// failure (or worse, double-apply on a now-half-transitioned task).
|
||||
reinsertPendingMove := func() {
|
||||
if s.messageQueue == nil {
|
||||
return
|
||||
}
|
||||
s.messageQueue.SetPendingMove(ctx, sessionID, move)
|
||||
}
|
||||
|
||||
if s.workflowStepGetter == nil || s.workflowStore == nil {
|
||||
s.logger.Warn("cannot apply pending move: workflow components missing",
|
||||
zap.String("task_id", taskID),
|
||||
zap.String("session_id", sessionID))
|
||||
reinsertPendingMove()
|
||||
return
|
||||
}
|
||||
|
||||
task, err := s.repo.GetTask(ctx, taskID)
|
||||
if err != nil {
|
||||
s.logger.Error("failed to load task for pending move",
|
||||
zap.String("task_id", taskID),
|
||||
zap.Error(err))
|
||||
reinsertPendingMove()
|
||||
return
|
||||
}
|
||||
fromStepID := task.WorkflowStepID
|
||||
if fromStepID == move.WorkflowStepID {
|
||||
// Step already matches — nothing to transition. Just leave the queued
|
||||
// prompt for the natural drain path. Don't reinsert: the move is
|
||||
// effectively complete since the task is already at the target step.
|
||||
s.logger.Info("pending move target equals current step; skipping transition",
|
||||
zap.String("task_id", taskID),
|
||||
zap.String("step_id", fromStepID))
|
||||
s.drainQueuedMessageAfterTransition(ctx, sessionID)
|
||||
return
|
||||
}
|
||||
|
||||
targetStep, err := s.workflowStepGetter.GetStep(ctx, move.WorkflowStepID)
|
||||
if err != nil || targetStep == nil {
|
||||
s.logger.Error("failed to load target step for pending move",
|
||||
zap.String("task_id", taskID),
|
||||
zap.String("target_step_id", move.WorkflowStepID),
|
||||
zap.Error(err))
|
||||
reinsertPendingMove()
|
||||
return
|
||||
}
|
||||
|
||||
// Mark the session WAITING_FOR_INPUT before processOnEnter runs. The agent
|
||||
// just finished its turn; the active-turn guard in processOnEnter would
|
||||
// otherwise see RUNNING and skip the on_enter processing.
|
||||
s.setSessionWaitingForInput(ctx, taskID, sessionID, session)
|
||||
|
||||
if err := s.workflowStore.ApplyTransition(ctx, taskID, sessionID, fromStepID, move.WorkflowStepID, engine.TriggerOnEnter); err != nil {
|
||||
s.logger.Error("failed to apply pending move transition",
|
||||
zap.String("task_id", taskID),
|
||||
zap.Error(err))
|
||||
// The hand-off prompt was queued by handleMoveTask before the move was
|
||||
// applied. Now that the move failed, the on_enter path that would have
|
||||
// drained the queue won't run, and handleAgentReady has already returned.
|
||||
// Drop the orphan so it can't be misdelivered to the source step's agent
|
||||
// on a future turn (it was authored for the move's *target* step).
|
||||
if s.messageQueue != nil {
|
||||
if _, ok := s.messageQueue.TakeQueued(ctx, sessionID); ok {
|
||||
s.publishQueueStatusEvent(ctx, sessionID)
|
||||
s.logger.Warn("dropped hand-off prompt after pending-move transition failure",
|
||||
zap.String("task_id", taskID),
|
||||
zap.String("session_id", sessionID))
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
s.logger.Info("applying pending move",
|
||||
zap.String("task_id", taskID),
|
||||
zap.String("session_id", sessionID),
|
||||
zap.String("from_step_id", fromStepID),
|
||||
zap.String("to_step_id", move.WorkflowStepID))
|
||||
|
||||
// Run on_exit + on_enter asynchronously. This call originated from
|
||||
// handleAgentReady on the WS event reader goroutine; processStepExitAndEnter
|
||||
// can take many seconds (resume + agentctl bootstrap) and would otherwise
|
||||
// block that reader, queueing other agent events behind it and creating
|
||||
// race conditions with concurrent on_turn_complete / agent.completed events
|
||||
// for the same session. The DB transition is already persisted above, so
|
||||
// it's safe to defer the rest.
|
||||
taskDescription := task.Description
|
||||
go s.processStepExitAndEnter(context.WithoutCancel(ctx), taskID, session, fromStepID, move.WorkflowStepID, taskDescription)
|
||||
}
|
||||
|
||||
// drainQueuedMessageAfterTransition takes any user-queued message and dispatches
|
||||
// it for execution. Used by processOnEnter branches that don't auto-start the
|
||||
// agent — without this, the message is orphaned because handleAgentReady skips
|
||||
@@ -777,9 +1036,28 @@ func (s *Service) autoStartStepPrompt(
|
||||
) error {
|
||||
sessionID := session.ID
|
||||
|
||||
// Take any queued message (e.g. from move_task_kandev with a hand-off
|
||||
// prompt) and merge it with the step's auto-start prompt — auto-start
|
||||
// content first, hand-off after — and forward attachments verbatim.
|
||||
// Track the original message so terminal failure paths can restore it
|
||||
// instead of dropping the user's prompt or attachments on the floor.
|
||||
takenMsg, mergedPrompt, attachments := s.takeAndMergeHandoffMessage(ctx, sessionID, prompt)
|
||||
prompt = mergedPrompt
|
||||
|
||||
// requeueTaken puts the original queued message back so a manual retry can
|
||||
// pick it up. Skip when shouldQueueIfBusy successfully re-queued the
|
||||
// concatenated prompt (the content is already preserved there).
|
||||
requeueTaken := func() {
|
||||
if takenMsg == nil {
|
||||
return
|
||||
}
|
||||
s.requeueMessage(ctx, takenMsg, takenMsg.QueuedBy)
|
||||
}
|
||||
|
||||
if shouldQueueIfBusy {
|
||||
queued, err := s.queueAutoStartPromptIfRunning(ctx, taskID, session, prompt, planMode)
|
||||
if err != nil {
|
||||
requeueTaken()
|
||||
return err
|
||||
}
|
||||
if queued {
|
||||
@@ -799,45 +1077,67 @@ func (s *Service) autoStartStepPrompt(
|
||||
zap.String("task_id", taskID),
|
||||
zap.String("session_id", sessionID),
|
||||
zap.String("step_name", stepName))
|
||||
_, err := s.StartCreatedSession(ctx, taskID, sessionID, session.AgentProfileID, prompt, true, planMode, nil)
|
||||
_, err := s.StartCreatedSession(ctx, taskID, sessionID, session.AgentProfileID, prompt, true, planMode, attachments)
|
||||
if err != nil {
|
||||
requeueTaken()
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
const maxRetryAttempts = 5
|
||||
for attempt := 1; attempt <= maxRetryAttempts; attempt++ {
|
||||
_, err := s.PromptTask(ctx, taskID, sessionID, prompt, "", planMode, nil)
|
||||
_, err := s.PromptTask(ctx, taskID, sessionID, prompt, "", planMode, attachments)
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
// ErrExecutionNotFound means ResumeSession landed on an execution that
|
||||
// the lifecycle manager no longer has (e.g. the post-resume agent
|
||||
// process failed to start and runAgentProcessAsync removed it). The
|
||||
// session's stored AgentExecutionID is now stale. Recover by clearing
|
||||
// it and routing through StartCreatedSession for a fresh launch — the
|
||||
// prompt is baked into LaunchPreparedSession so we don't lose it.
|
||||
if errors.Is(err, executor.ErrExecutionNotFound) {
|
||||
s.logger.Warn("auto-start: PromptTask hit missing execution; falling back to fresh launch",
|
||||
zap.String("task_id", taskID),
|
||||
zap.String("session_id", sessionID),
|
||||
zap.String("step_name", stepName))
|
||||
return s.fallbackFreshLaunchOnMissingExecution(ctx, taskID, sessionID, prompt, planMode, takenMsg, attachments)
|
||||
}
|
||||
|
||||
// "already has an agent running" means the execution store still tracks
|
||||
// an active agent for this session (e.g. session state is CREATED but
|
||||
// the agent was launched by a concurrent path). Queue instead of retrying.
|
||||
if isAgentAlreadyRunningError(err) && shouldQueueIfBusy {
|
||||
if queueErr := s.queueAutoStartPrompt(ctx, taskID, sessionID, prompt, planMode); queueErr != nil {
|
||||
requeueTaken()
|
||||
return queueErr
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
if !isAgentPromptInProgressError(err) && !isTransientPromptError(err) && !isSessionResetInProgressError(err) {
|
||||
requeueTaken()
|
||||
return err
|
||||
}
|
||||
|
||||
if shouldQueueIfBusy {
|
||||
if queueErr := s.queueAutoStartPrompt(ctx, taskID, sessionID, prompt, planMode); queueErr != nil {
|
||||
requeueTaken()
|
||||
return queueErr
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
if attempt == maxRetryAttempts {
|
||||
requeueTaken()
|
||||
return err
|
||||
}
|
||||
|
||||
delay := time.Duration(50*(1<<(attempt-1))) * time.Millisecond
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
requeueTaken()
|
||||
return fmt.Errorf("auto-start context canceled: %w", ctx.Err())
|
||||
case <-time.After(delay):
|
||||
}
|
||||
@@ -846,6 +1146,85 @@ func (s *Service) autoStartStepPrompt(
|
||||
return nil
|
||||
}
|
||||
|
||||
// fallbackFreshLaunchOnMissingExecution recovers from a PromptTask that returned
|
||||
// ErrExecutionNotFound — the session's stored AgentExecutionID points at an
|
||||
// execution the lifecycle manager doesn't have, so the resume path is dead.
|
||||
// Clear the stale ID, flip state to CREATED, and route through StartCreatedSession
|
||||
// (which uses LaunchPreparedSession with the prompt baked in — bypassing resume).
|
||||
// On further failure, the queued message is restored so a manual retry recovers it.
|
||||
func (s *Service) fallbackFreshLaunchOnMissingExecution(
|
||||
ctx context.Context,
|
||||
taskID, sessionID, prompt string,
|
||||
planMode bool,
|
||||
takenMsg *messagequeue.QueuedMessage,
|
||||
attachments []v1.MessageAttachment,
|
||||
) error {
|
||||
requeue := func() {
|
||||
if takenMsg != nil {
|
||||
s.requeueMessage(ctx, takenMsg, takenMsg.QueuedBy)
|
||||
}
|
||||
}
|
||||
|
||||
fresh, err := s.repo.GetTaskSession(ctx, sessionID)
|
||||
if err != nil {
|
||||
s.logger.Error("auto-start fallback: failed to load session",
|
||||
zap.String("session_id", sessionID), zap.Error(err))
|
||||
requeue()
|
||||
return err
|
||||
}
|
||||
|
||||
fresh.AgentExecutionID = ""
|
||||
fresh.State = models.TaskSessionStateCreated
|
||||
fresh.UpdatedAt = time.Now().UTC()
|
||||
if err := s.repo.UpdateTaskSession(ctx, fresh); err != nil {
|
||||
s.logger.Error("auto-start fallback: failed to reset session for fresh launch",
|
||||
zap.String("session_id", sessionID), zap.Error(err))
|
||||
requeue()
|
||||
return err
|
||||
}
|
||||
|
||||
if _, err := s.StartCreatedSession(ctx, taskID, sessionID, fresh.AgentProfileID, prompt, true, planMode, attachments); err != nil {
|
||||
s.logger.Error("auto-start fallback: fresh launch failed",
|
||||
zap.String("session_id", sessionID), zap.Error(err))
|
||||
requeue()
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// takeAndMergeHandoffMessage drains any queued hand-off message for the session
|
||||
// (set by handleMoveTask via move_task_kandev or by drainQueuedMessageAfterTransition)
|
||||
// and merges its content + attachments into the auto-start prompt. Returns the
|
||||
// original queued message (so terminal failure paths can re-queue it via
|
||||
// requeueMessage), the merged prompt, and the converted attachments. Empty
|
||||
// messages with neither content nor attachments are left in the queue.
|
||||
func (s *Service) takeAndMergeHandoffMessage(ctx context.Context, sessionID, basePrompt string) (*messagequeue.QueuedMessage, string, []v1.MessageAttachment) {
|
||||
if s.messageQueue == nil {
|
||||
return nil, basePrompt, nil
|
||||
}
|
||||
msg, ok := s.messageQueue.TakeQueued(ctx, sessionID)
|
||||
if !ok || msg == nil || (msg.Content == "" && len(msg.Attachments) == 0) {
|
||||
return nil, basePrompt, nil
|
||||
}
|
||||
prompt := basePrompt
|
||||
if msg.Content != "" {
|
||||
prompt = basePrompt + "\n\n" + msg.Content
|
||||
}
|
||||
var attachments []v1.MessageAttachment
|
||||
if len(msg.Attachments) > 0 {
|
||||
attachments = make([]v1.MessageAttachment, 0, len(msg.Attachments))
|
||||
for _, a := range msg.Attachments {
|
||||
attachments = append(attachments, v1.MessageAttachment{
|
||||
Type: a.Type,
|
||||
Data: a.Data,
|
||||
MimeType: a.MimeType,
|
||||
})
|
||||
}
|
||||
}
|
||||
s.publishQueueStatusEvent(ctx, sessionID)
|
||||
return msg, prompt, attachments
|
||||
}
|
||||
|
||||
// recordAutoStartMessage creates a user message for a workflow auto-start prompt
|
||||
// so it appears in the chat history. The prompt content includes system-injected
|
||||
// tags which are stripped when displayed to users via ToAPI().
|
||||
|
||||
@@ -162,6 +162,326 @@ func TestSwitchSessionForStep(t *testing.T) {
|
||||
})
|
||||
}
|
||||
|
||||
// TestSwitchSessionForStep_ReusesExistingProfileSession verifies the core
|
||||
// requirement: when switching to a profile that already has a session on this
|
||||
// task, switchSessionForStep reuses it instead of creating a third session.
|
||||
// Covers the A→B→A round trip (and beyond) at the unit-test level.
|
||||
func TestSwitchSessionForStep_ReusesExistingProfileSession(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
now := time.Now().UTC()
|
||||
|
||||
repo := setupTestRepo(t)
|
||||
|
||||
ws := &models.Workspace{ID: "ws1", Name: "Test", CreatedAt: now, UpdatedAt: now}
|
||||
_ = repo.CreateWorkspace(ctx, ws)
|
||||
wf := &models.Workflow{ID: "wf1", WorkspaceID: "ws1", Name: "WF", CreatedAt: now, UpdatedAt: now}
|
||||
_ = repo.CreateWorkflow(ctx, wf)
|
||||
task := &models.Task{
|
||||
ID: "t1", WorkflowID: "wf1", WorkflowStepID: "step1",
|
||||
Title: "Test", Description: "Test", State: v1.TaskStateInProgress,
|
||||
CreatedAt: now, UpdatedAt: now,
|
||||
}
|
||||
_ = repo.CreateTask(ctx, task)
|
||||
|
||||
// Prior session for profile-A — was active before, then completed when
|
||||
// the workflow switched away from this profile last time.
|
||||
completedAt := now.Add(-2 * time.Minute)
|
||||
prior := &models.TaskSession{
|
||||
ID: "session-a",
|
||||
TaskID: "t1",
|
||||
AgentProfileID: "profile-a",
|
||||
ExecutorID: "exec-local",
|
||||
ExecutorProfileID: "ep1",
|
||||
State: models.TaskSessionStateCompleted,
|
||||
IsPrimary: false,
|
||||
CompletedAt: &completedAt,
|
||||
StartedAt: now.Add(-3 * time.Minute),
|
||||
UpdatedAt: completedAt,
|
||||
}
|
||||
_ = repo.CreateTaskSession(ctx, prior)
|
||||
|
||||
// Currently-active session for profile-B — about to be switched away from.
|
||||
current := &models.TaskSession{
|
||||
ID: "session-b",
|
||||
TaskID: "t1",
|
||||
AgentProfileID: "profile-b",
|
||||
ExecutorID: "exec-local",
|
||||
ExecutorProfileID: "ep1",
|
||||
AgentExecutionID: "ae-b",
|
||||
State: models.TaskSessionStateRunning,
|
||||
IsPrimary: true,
|
||||
StartedAt: now,
|
||||
UpdatedAt: now,
|
||||
}
|
||||
_ = repo.CreateTaskSession(ctx, current)
|
||||
|
||||
taskRepo := newMockTaskRepo()
|
||||
taskRepo.tasks["t1"] = &v1.Task{
|
||||
ID: "t1", WorkspaceID: "ws1", WorkflowID: "wf1",
|
||||
Title: "Test", Description: "Test", State: v1.TaskStateInProgress,
|
||||
}
|
||||
|
||||
agentMgr := &mockAgentManager{}
|
||||
log := testLogger()
|
||||
exec := executor.NewExecutor(agentMgr, repo, log, executor.ExecutorConfig{})
|
||||
sched := scheduler.NewScheduler(queue.NewTaskQueue(100), exec, taskRepo, log, scheduler.SchedulerConfig{})
|
||||
svc := &Service{
|
||||
logger: log,
|
||||
repo: repo,
|
||||
workflowStepGetter: newMockStepGetter(),
|
||||
taskRepo: taskRepo,
|
||||
agentManager: agentMgr,
|
||||
messageQueue: messagequeue.NewService(log),
|
||||
executor: exec,
|
||||
scheduler: sched,
|
||||
}
|
||||
|
||||
revived, err := svc.switchSessionForStep(ctx, "t1", current, "profile-a")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
// Critical: reuse must return the existing session — NOT a brand-new id.
|
||||
if revived == nil || revived.ID != "session-a" {
|
||||
t.Fatalf("expected reused session-a, got %+v", revived)
|
||||
}
|
||||
|
||||
// Total session count must remain 2 — no third session created.
|
||||
sessions, err := repo.ListTaskSessions(ctx, "t1")
|
||||
if err != nil {
|
||||
t.Fatalf("failed to list sessions: %v", err)
|
||||
}
|
||||
if len(sessions) != 2 {
|
||||
t.Errorf("expected 2 sessions after reuse, got %d", len(sessions))
|
||||
}
|
||||
|
||||
// The reused session must be back to a non-terminal state (so it can
|
||||
// receive the next prompt) and be primary. Specifically, since the prior
|
||||
// session has no executors_running record (never launched), it should
|
||||
// flip to CREATED so autoStartStepPrompt routes through StartCreatedSession
|
||||
// for a fresh launch (instead of hitting "no executor record" in
|
||||
// ensureSessionRunning).
|
||||
reused, _ := repo.GetTaskSession(ctx, "session-a")
|
||||
if reused.State != models.TaskSessionStateCreated {
|
||||
t.Errorf("never-launched reused session must be CREATED (so StartCreatedSession launches it fresh), got %s", reused.State)
|
||||
}
|
||||
if reused.CompletedAt != nil {
|
||||
t.Error("reused session must have CompletedAt cleared")
|
||||
}
|
||||
if !reused.IsPrimary {
|
||||
t.Error("reused session must be primary")
|
||||
}
|
||||
|
||||
// The previous current session-b must now be COMPLETED, not primary.
|
||||
parked, _ := repo.GetTaskSession(ctx, "session-b")
|
||||
if parked.State != models.TaskSessionStateCompleted {
|
||||
t.Errorf("previous current session must be COMPLETED, got %s", parked.State)
|
||||
}
|
||||
if parked.IsPrimary {
|
||||
t.Error("previous current session must no longer be primary")
|
||||
}
|
||||
}
|
||||
|
||||
// TestSwitchSessionForStep_ReusesPreviouslyLaunchedSession covers the other
|
||||
// branch of the revive: when the reused session has an executors_running
|
||||
// record (it was previously launched and has a resume token), it flips to
|
||||
// WAITING_FOR_INPUT so PromptTask's ensureSessionRunning lazy-resumes the
|
||||
// agent via ResumeSession (preserving its prior conversation context).
|
||||
func TestSwitchSessionForStep_ReusesPreviouslyLaunchedSession(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
now := time.Now().UTC()
|
||||
|
||||
repo := setupTestRepo(t)
|
||||
|
||||
ws := &models.Workspace{ID: "ws1", Name: "Test", CreatedAt: now, UpdatedAt: now}
|
||||
_ = repo.CreateWorkspace(ctx, ws)
|
||||
wf := &models.Workflow{ID: "wf1", WorkspaceID: "ws1", Name: "WF", CreatedAt: now, UpdatedAt: now}
|
||||
_ = repo.CreateWorkflow(ctx, wf)
|
||||
task := &models.Task{
|
||||
ID: "t1", WorkflowID: "wf1", WorkflowStepID: "step1",
|
||||
Title: "Test", Description: "Test", State: v1.TaskStateInProgress,
|
||||
CreatedAt: now, UpdatedAt: now,
|
||||
}
|
||||
_ = repo.CreateTask(ctx, task)
|
||||
|
||||
// Prior session for profile-A — was previously active and has the
|
||||
// signals of a real launch: an executors_running record with a resume
|
||||
// token. This should route through the WAITING_FOR_INPUT branch of
|
||||
// reviveReusedSession.
|
||||
completedAt := now.Add(-2 * time.Minute)
|
||||
prior := &models.TaskSession{
|
||||
ID: "session-a",
|
||||
TaskID: "t1",
|
||||
AgentProfileID: "profile-a",
|
||||
ExecutorID: "exec-local",
|
||||
ExecutorProfileID: "ep1",
|
||||
AgentExecutionID: "ae-a-1",
|
||||
State: models.TaskSessionStateCompleted,
|
||||
CompletedAt: &completedAt,
|
||||
StartedAt: now.Add(-3 * time.Minute),
|
||||
UpdatedAt: completedAt,
|
||||
}
|
||||
_ = repo.CreateTaskSession(ctx, prior)
|
||||
_ = repo.UpsertExecutorRunning(ctx, &models.ExecutorRunning{
|
||||
ID: "er-a", SessionID: "session-a", TaskID: "t1",
|
||||
ResumeToken: "acp-session-a",
|
||||
Resumable: true,
|
||||
CreatedAt: completedAt, UpdatedAt: completedAt,
|
||||
})
|
||||
|
||||
current := &models.TaskSession{
|
||||
ID: "session-b",
|
||||
TaskID: "t1",
|
||||
AgentProfileID: "profile-b",
|
||||
ExecutorID: "exec-local",
|
||||
ExecutorProfileID: "ep1",
|
||||
AgentExecutionID: "ae-b",
|
||||
State: models.TaskSessionStateRunning,
|
||||
IsPrimary: true,
|
||||
StartedAt: now,
|
||||
UpdatedAt: now,
|
||||
}
|
||||
_ = repo.CreateTaskSession(ctx, current)
|
||||
|
||||
taskRepo := newMockTaskRepo()
|
||||
taskRepo.tasks["t1"] = &v1.Task{
|
||||
ID: "t1", WorkspaceID: "ws1", WorkflowID: "wf1",
|
||||
Title: "Test", Description: "Test", State: v1.TaskStateInProgress,
|
||||
}
|
||||
|
||||
agentMgr := &mockAgentManager{}
|
||||
log := testLogger()
|
||||
exec := executor.NewExecutor(agentMgr, repo, log, executor.ExecutorConfig{})
|
||||
sched := scheduler.NewScheduler(queue.NewTaskQueue(100), exec, taskRepo, log, scheduler.SchedulerConfig{})
|
||||
svc := &Service{
|
||||
logger: log,
|
||||
repo: repo,
|
||||
workflowStepGetter: newMockStepGetter(),
|
||||
taskRepo: taskRepo,
|
||||
agentManager: agentMgr,
|
||||
messageQueue: messagequeue.NewService(log),
|
||||
executor: exec,
|
||||
scheduler: sched,
|
||||
}
|
||||
|
||||
revived, err := svc.switchSessionForStep(ctx, "t1", current, "profile-a")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if revived == nil || revived.ID != "session-a" {
|
||||
t.Fatalf("expected reused session-a, got %+v", revived)
|
||||
}
|
||||
|
||||
reused, _ := repo.GetTaskSession(ctx, "session-a")
|
||||
if reused.State != models.TaskSessionStateWaitingForInput {
|
||||
t.Errorf("previously-launched reused session must be WAITING_FOR_INPUT (so PromptTask lazy-resumes via ResumeSession), got %s", reused.State)
|
||||
}
|
||||
}
|
||||
|
||||
// TestSwitchSessionForStep_ReusesFailedSession exercises the requirement that
|
||||
// FAILED sessions are reused too. Without this, a previously-failed session
|
||||
// would be skipped and a fresh one created, leaving the FAILED one as a
|
||||
// duplicate tab in the UI showing its stale error banner.
|
||||
func TestSwitchSessionForStep_ReusesFailedSession(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
now := time.Now().UTC()
|
||||
|
||||
repo := setupTestRepo(t)
|
||||
|
||||
ws := &models.Workspace{ID: "ws1", Name: "Test", CreatedAt: now, UpdatedAt: now}
|
||||
_ = repo.CreateWorkspace(ctx, ws)
|
||||
wf := &models.Workflow{ID: "wf1", WorkspaceID: "ws1", Name: "WF", CreatedAt: now, UpdatedAt: now}
|
||||
_ = repo.CreateWorkflow(ctx, wf)
|
||||
task := &models.Task{
|
||||
ID: "t1", WorkflowID: "wf1", WorkflowStepID: "step1",
|
||||
Title: "Test", Description: "Test", State: v1.TaskStateInProgress,
|
||||
CreatedAt: now, UpdatedAt: now,
|
||||
}
|
||||
_ = repo.CreateTask(ctx, task)
|
||||
|
||||
failedAt := now.Add(-2 * time.Minute)
|
||||
prior := &models.TaskSession{
|
||||
ID: "session-a",
|
||||
TaskID: "t1",
|
||||
AgentProfileID: "profile-a",
|
||||
ExecutorID: "exec-local",
|
||||
ExecutorProfileID: "ep1",
|
||||
AgentExecutionID: "ae-a",
|
||||
State: models.TaskSessionStateFailed,
|
||||
ErrorMessage: "execution already running",
|
||||
CompletedAt: &failedAt,
|
||||
StartedAt: now.Add(-3 * time.Minute),
|
||||
UpdatedAt: failedAt,
|
||||
}
|
||||
_ = repo.CreateTaskSession(ctx, prior)
|
||||
_ = repo.UpsertExecutorRunning(ctx, &models.ExecutorRunning{
|
||||
ID: "er-a", SessionID: "session-a", TaskID: "t1",
|
||||
ResumeToken: "acp-session-a",
|
||||
Resumable: true,
|
||||
CreatedAt: failedAt, UpdatedAt: failedAt,
|
||||
})
|
||||
|
||||
current := &models.TaskSession{
|
||||
ID: "session-b",
|
||||
TaskID: "t1",
|
||||
AgentProfileID: "profile-b",
|
||||
ExecutorID: "exec-local",
|
||||
ExecutorProfileID: "ep1",
|
||||
AgentExecutionID: "ae-b",
|
||||
State: models.TaskSessionStateRunning,
|
||||
IsPrimary: true,
|
||||
StartedAt: now,
|
||||
UpdatedAt: now,
|
||||
}
|
||||
_ = repo.CreateTaskSession(ctx, current)
|
||||
|
||||
taskRepo := newMockTaskRepo()
|
||||
taskRepo.tasks["t1"] = &v1.Task{
|
||||
ID: "t1", WorkspaceID: "ws1", WorkflowID: "wf1",
|
||||
Title: "Test", Description: "Test", State: v1.TaskStateInProgress,
|
||||
}
|
||||
|
||||
agentMgr := &mockAgentManager{}
|
||||
log := testLogger()
|
||||
exec := executor.NewExecutor(agentMgr, repo, log, executor.ExecutorConfig{})
|
||||
sched := scheduler.NewScheduler(queue.NewTaskQueue(100), exec, taskRepo, log, scheduler.SchedulerConfig{})
|
||||
svc := &Service{
|
||||
logger: log,
|
||||
repo: repo,
|
||||
workflowStepGetter: newMockStepGetter(),
|
||||
taskRepo: taskRepo,
|
||||
agentManager: agentMgr,
|
||||
messageQueue: messagequeue.NewService(log),
|
||||
executor: exec,
|
||||
scheduler: sched,
|
||||
}
|
||||
|
||||
revived, err := svc.switchSessionForStep(ctx, "t1", current, "profile-a")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if revived == nil || revived.ID != "session-a" {
|
||||
t.Fatalf("expected reused FAILED session-a, got %+v", revived)
|
||||
}
|
||||
|
||||
// No duplicate session must be created.
|
||||
sessions, _ := repo.ListTaskSessions(ctx, "t1")
|
||||
if len(sessions) != 2 {
|
||||
t.Errorf("expected 2 sessions, got %d (FAILED session was not reused)", len(sessions))
|
||||
}
|
||||
|
||||
reused, _ := repo.GetTaskSession(ctx, "session-a")
|
||||
if reused.State != models.TaskSessionStateWaitingForInput {
|
||||
t.Errorf("FAILED reused session must flip to WAITING_FOR_INPUT (lazy-resume via token), got %s", reused.State)
|
||||
}
|
||||
if reused.ErrorMessage != "" {
|
||||
t.Errorf("FAILED reused session must have ErrorMessage cleared, got %q", reused.ErrorMessage)
|
||||
}
|
||||
if reused.CompletedAt != nil {
|
||||
t.Error("FAILED reused session must have CompletedAt cleared")
|
||||
}
|
||||
}
|
||||
|
||||
func TestProcessOnEnter_ProfileSwitch(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
|
||||
|
||||
@@ -16,18 +16,75 @@ import (
|
||||
type Service struct {
|
||||
// In-memory storage: sessionID -> QueuedMessage
|
||||
queued map[string]*QueuedMessage
|
||||
mu sync.RWMutex
|
||||
logger *logger.Logger
|
||||
// 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),
|
||||
logger: log.WithFields(zap.String("component", "message-queue")),
|
||||
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()
|
||||
|
||||
@@ -87,6 +87,85 @@ func TestQueueMessage(t *testing.T) {
|
||||
})
|
||||
}
|
||||
|
||||
func TestTransferSession(t *testing.T) {
|
||||
t.Run("moves queued message and pending move from old to new session", func(t *testing.T) {
|
||||
svc := setupService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
_, err := svc.QueueMessage(ctx, "old-sess", "task-1", "hand-off prompt", "", "mcp-move-task", false, nil)
|
||||
require.NoError(t, err)
|
||||
svc.SetPendingMove(ctx, "old-sess", &PendingMove{
|
||||
TaskID: "task-1",
|
||||
WorkflowStepID: "step-b",
|
||||
})
|
||||
|
||||
svc.TransferSession(ctx, "old-sess", "new-sess")
|
||||
|
||||
// Old session is empty.
|
||||
_, exists := svc.TakeQueued(ctx, "old-sess")
|
||||
assert.False(t, exists)
|
||||
_, exists = svc.TakePendingMove(ctx, "old-sess")
|
||||
assert.False(t, exists)
|
||||
|
||||
// New session has both.
|
||||
msg, exists := svc.TakeQueued(ctx, "new-sess")
|
||||
require.True(t, exists)
|
||||
assert.Equal(t, "hand-off prompt", msg.Content)
|
||||
assert.Equal(t, "new-sess", msg.SessionID)
|
||||
|
||||
move, exists := svc.TakePendingMove(ctx, "new-sess")
|
||||
require.True(t, exists)
|
||||
assert.Equal(t, "step-b", move.WorkflowStepID)
|
||||
})
|
||||
|
||||
t.Run("no-op when source session is empty", func(t *testing.T) {
|
||||
svc := setupService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
svc.TransferSession(ctx, "empty-sess", "new-sess")
|
||||
|
||||
_, exists := svc.TakeQueued(ctx, "new-sess")
|
||||
assert.False(t, exists)
|
||||
})
|
||||
}
|
||||
|
||||
func TestPendingMove(t *testing.T) {
|
||||
t.Run("set then take returns the move and clears it", func(t *testing.T) {
|
||||
svc := setupService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
svc.SetPendingMove(ctx, "session-1", &PendingMove{
|
||||
TaskID: "task-1",
|
||||
WorkflowID: "wf-1",
|
||||
WorkflowStepID: "step-2",
|
||||
Position: 3,
|
||||
})
|
||||
|
||||
got, exists := svc.TakePendingMove(ctx, "session-1")
|
||||
require.True(t, exists)
|
||||
assert.Equal(t, "task-1", got.TaskID)
|
||||
assert.Equal(t, "step-2", got.WorkflowStepID)
|
||||
assert.Equal(t, 3, got.Position)
|
||||
assert.NotZero(t, got.QueuedAt)
|
||||
|
||||
// Idempotent — second take returns nothing.
|
||||
_, exists = svc.TakePendingMove(ctx, "session-1")
|
||||
assert.False(t, exists)
|
||||
})
|
||||
|
||||
t.Run("setting twice replaces the previous move", func(t *testing.T) {
|
||||
svc := setupService(t)
|
||||
ctx := context.Background()
|
||||
|
||||
svc.SetPendingMove(ctx, "session-1", &PendingMove{TaskID: "task-1", WorkflowStepID: "step-a"})
|
||||
svc.SetPendingMove(ctx, "session-1", &PendingMove{TaskID: "task-1", WorkflowStepID: "step-b"})
|
||||
|
||||
got, exists := svc.TakePendingMove(ctx, "session-1")
|
||||
require.True(t, exists)
|
||||
assert.Equal(t, "step-b", got.WorkflowStepID)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTakeQueued(t *testing.T) {
|
||||
t.Run("retrieves and removes queued message", func(t *testing.T) {
|
||||
svc := setupService(t)
|
||||
|
||||
@@ -27,3 +27,15 @@ type QueueStatus struct {
|
||||
IsQueued bool `json:"is_queued"` // Whether a message is queued
|
||||
Message *QueuedMessage `json:"message"` // The queued message (nil if not queued)
|
||||
}
|
||||
|
||||
// PendingMove represents a workflow step move requested by an agent (via
|
||||
// move_task_kandev) while its turn is still active. Applied by handleAgentReady
|
||||
// once the turn ends, to avoid racing the on_enter processing against the
|
||||
// agent's running turn.
|
||||
type PendingMove struct {
|
||||
TaskID string `json:"task_id"`
|
||||
WorkflowID string `json:"workflow_id"`
|
||||
WorkflowStepID string `json:"workflow_step_id"`
|
||||
Position int `json:"position"`
|
||||
QueuedAt time.Time `json:"queued_at"`
|
||||
}
|
||||
|
||||
@@ -332,6 +332,7 @@ func NewService(
|
||||
handlers := watcher.EventHandlers{
|
||||
OnTaskDeleted: s.handleTaskDeleted,
|
||||
OnAgentRunning: s.handleAgentRunning,
|
||||
OnAgentBootReady: s.handleAgentBootReady,
|
||||
OnAgentReady: s.handleAgentReady,
|
||||
OnAgentCompleted: s.handleAgentCompleted,
|
||||
OnAgentFailed: s.handleAgentFailed,
|
||||
|
||||
@@ -48,6 +48,13 @@ func isSessionResetInProgressError(err error) bool {
|
||||
return err != nil && (errors.Is(err, ErrSessionResetInProgress) || strings.Contains(err.Error(), ErrSessionResetInProgress.Error()))
|
||||
}
|
||||
|
||||
// isTransientPromptError reports whether a prompt error is worth retrying via
|
||||
// the queue. ErrExecutionNotFound is intentionally NOT included here:
|
||||
// callers that can recover (autoStartStepPrompt → fallbackFreshLaunchOnMissingExecution)
|
||||
// detect it explicitly via errors.Is and route differently; callers that
|
||||
// can't (executeQueuedMessage) should not infinite-requeue on it. Treating
|
||||
// "execution not found" as transient blanket-applies a retry that loops
|
||||
// forever when the execution is genuinely gone.
|
||||
func isTransientPromptError(err error) bool {
|
||||
if err == nil {
|
||||
return false
|
||||
@@ -350,23 +357,26 @@ func (s *Service) StartCreatedSession(ctx context.Context, taskID, sessionID, ag
|
||||
effectivePrompt = task.Description
|
||||
}
|
||||
|
||||
// Process on_turn_start before launching the agent, just like user-initiated messages.
|
||||
// This allows workflow transitions (e.g. move_to_next) to fire on the initial prompt.
|
||||
// If the target step has a different agent profile, executeStepTransition switches
|
||||
// the session — so we need to pick up the new session afterwards.
|
||||
s.processOnTurnStartViaEngine(ctx, taskID, session)
|
||||
|
||||
// Re-read the session after on_turn_start may have switched it (agent profile change).
|
||||
// The original session may have been completed; use the active session for this task.
|
||||
// NOTE: on_turn_start is intentionally NOT processed here.
|
||||
// - User-initiated path: dispatchPromptAsync (message_handlers.go) already
|
||||
// calls ProcessOnTurnStart before invoking StartCreatedSession via
|
||||
// forwardMessageAsPrompt, so on_turn_start has already fired.
|
||||
// - Workflow auto-start path: autoStartStepPrompt calls us because the
|
||||
// workflow just transitioned us into this step (via on_turn_complete or
|
||||
// on_enter). Firing on_turn_start again here cascades the workflow back
|
||||
// out before the step's auto-start prompt can be delivered to its agent.
|
||||
//
|
||||
// However, for the user-initiated path, on_turn_start may have switched the
|
||||
// session profile already, in which case the session ID we were called with
|
||||
// is now COMPLETED and we need to redirect to the new active session.
|
||||
session, err = s.repo.GetTaskSession(ctx, sessionID)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to reload session after on_turn_start: %w", err)
|
||||
return nil, fmt.Errorf("failed to reload session: %w", err)
|
||||
}
|
||||
if session.State == models.TaskSessionStateCompleted {
|
||||
// on_turn_start switched the agent profile — find the new active session.
|
||||
activeSession, activeErr := s.repo.GetActiveTaskSessionByTaskID(ctx, taskID)
|
||||
if activeErr != nil || activeSession == nil {
|
||||
return nil, fmt.Errorf("session was switched during on_turn_start but no active session found: %w", activeErr)
|
||||
return nil, fmt.Errorf("session was switched but no active session found: %w", activeErr)
|
||||
}
|
||||
session = activeSession
|
||||
sessionID = activeSession.ID
|
||||
@@ -889,6 +899,9 @@ func (s *Service) ensureSessionRunning(ctx context.Context, sessionID string, se
|
||||
}
|
||||
|
||||
// Use context.WithoutCancel to prevent WebSocket request timeout from canceling the resume.
|
||||
// The lifecycle layer publishes events.AgentBootReady (handled by handleAgentBootReady)
|
||||
// when the agent's ACP session initializes — that's what unblocks waitForSessionReady,
|
||||
// no flag-tracking needed.
|
||||
resumeCtx := context.WithoutCancel(ctx)
|
||||
if _, err = s.executor.ResumeSession(resumeCtx, session, true); err != nil {
|
||||
if errors.Is(err, executor.ErrExecutionAlreadyRunning) {
|
||||
@@ -923,6 +936,10 @@ func (s *Service) startAgentOnPreparedWorkspace(ctx context.Context, sessionID s
|
||||
zap.String("session_id", sessionID),
|
||||
zap.String("agent_execution_id", session.AgentExecutionID))
|
||||
|
||||
// Boot ready is published as events.AgentBootReady by the lifecycle layer
|
||||
// and routed to handleAgentBootReady, which flips the session to
|
||||
// WAITING_FOR_INPUT — that's what waitForSessionReady polls for. No flag
|
||||
// tracking required here.
|
||||
launchCtx := context.WithoutCancel(ctx)
|
||||
task, err := s.scheduler.GetTask(launchCtx, session.TaskID)
|
||||
if err != nil {
|
||||
@@ -1614,6 +1631,17 @@ func (s *Service) PromptTask(ctx context.Context, taskID, sessionID string, prom
|
||||
return nil, fmt.Errorf("failed to ensure session is running: %w", err)
|
||||
}
|
||||
|
||||
// Reload session after ensureSessionRunning. If a resume happened, ResumeSession
|
||||
// updated the session's AgentExecutionID via persistResumeState — but only on the
|
||||
// pointer it received. If anything along the way swapped the pointer or the
|
||||
// caller's struct is otherwise stale (e.g. a concurrent write), executor.Prompt
|
||||
// would call PromptAgent with the OLD execution ID and get ErrExecutionNotFound.
|
||||
// Re-reading from the DB after ensureSessionRunning guarantees we use the
|
||||
// freshly-persisted AgentExecutionID.
|
||||
if reloaded, err := s.repo.GetTaskSession(ctx, sessionID); err == nil && reloaded != nil {
|
||||
session = reloaded
|
||||
}
|
||||
|
||||
// Inject config context for config-mode sessions (dedicated settings chat, not plan mode)
|
||||
effectivePrompt := prompt
|
||||
if cm, ok := session.Metadata["config_mode"].(bool); ok && cm {
|
||||
|
||||
@@ -92,7 +92,8 @@ type EventHandlers struct {
|
||||
// Agent events
|
||||
OnAgentStarted func(ctx context.Context, data AgentEventData)
|
||||
OnAgentRunning func(ctx context.Context, data AgentEventData)
|
||||
OnAgentReady func(ctx context.Context, data AgentEventData)
|
||||
OnAgentBootReady func(ctx context.Context, data AgentEventData) // ACP session initialized; idle, no turn yet
|
||||
OnAgentReady func(ctx context.Context, data AgentEventData) // Turn ended; agent idle waiting for follow-up
|
||||
OnAgentCompleted func(ctx context.Context, data AgentEventData)
|
||||
OnAgentFailed func(ctx context.Context, data AgentEventData)
|
||||
OnAgentStopped func(ctx context.Context, data AgentEventData)
|
||||
@@ -280,6 +281,7 @@ func (w *Watcher) subscribeToAgentEvents() error {
|
||||
}{
|
||||
{events.AgentStarted, w.handlers.OnAgentStarted},
|
||||
{events.AgentRunning, w.handlers.OnAgentRunning},
|
||||
{events.AgentBootReady, w.handlers.OnAgentBootReady},
|
||||
{events.AgentReady, w.handlers.OnAgentReady},
|
||||
{events.AgentCompleted, w.handlers.OnAgentCompleted},
|
||||
{events.AgentFailed, w.handlers.OnAgentFailed},
|
||||
|
||||
@@ -78,6 +78,7 @@ export function taskToState(
|
||||
tasks: {
|
||||
activeTaskId: task.id,
|
||||
activeSessionId: resolvedSessionId,
|
||||
pinnedSessionId: null,
|
||||
},
|
||||
messages:
|
||||
resolvedSessionId && messages
|
||||
|
||||
@@ -5,7 +5,7 @@ export const defaultKanbanState: KanbanSliceState = {
|
||||
kanban: { workflowId: null, steps: [], tasks: [] },
|
||||
kanbanMulti: { snapshots: {}, isLoading: false },
|
||||
workflows: { items: [], activeId: null },
|
||||
tasks: { activeTaskId: null, activeSessionId: null },
|
||||
tasks: { activeTaskId: null, activeSessionId: null, pinnedSessionId: null },
|
||||
};
|
||||
|
||||
export const createKanbanSlice: StateCreator<
|
||||
@@ -46,17 +46,29 @@ export const createKanbanSlice: StateCreator<
|
||||
set((draft) => {
|
||||
draft.tasks.activeTaskId = taskId;
|
||||
draft.tasks.activeSessionId = null;
|
||||
// New task → drop any pin; the pin only applies within a single task.
|
||||
draft.tasks.pinnedSessionId = null;
|
||||
});
|
||||
},
|
||||
setActiveSession: (taskId, sessionId) => {
|
||||
set((draft) => {
|
||||
draft.tasks.activeTaskId = taskId;
|
||||
draft.tasks.activeSessionId = sessionId;
|
||||
// User-initiated selection: pin so WS auto-replace handoff respects it.
|
||||
draft.tasks.pinnedSessionId = sessionId;
|
||||
});
|
||||
},
|
||||
setActiveSessionAuto: (taskId, sessionId) => {
|
||||
set((draft) => {
|
||||
draft.tasks.activeTaskId = taskId;
|
||||
draft.tasks.activeSessionId = sessionId;
|
||||
// Auto-driven (WS) selection: don't touch pinnedSessionId.
|
||||
});
|
||||
},
|
||||
clearActiveSession: () =>
|
||||
set((draft) => {
|
||||
draft.tasks.activeSessionId = null;
|
||||
draft.tasks.pinnedSessionId = null;
|
||||
}),
|
||||
setWorkflowSnapshot: (workflowId, data) =>
|
||||
set((draft) => {
|
||||
|
||||
@@ -75,6 +75,12 @@ export type WorkflowsState = {
|
||||
export type TaskState = {
|
||||
activeTaskId: string | null;
|
||||
activeSessionId: string | null;
|
||||
// pinnedSessionId tracks the session the USER explicitly selected.
|
||||
// Set by setActiveSession (user-initiated). Cleared when navigating to a
|
||||
// different task. WS auto-adopt paths use setActiveSessionAuto which leaves
|
||||
// pinnedSessionId alone — and skip auto-replace when the terminating session
|
||||
// matches the pin (the user wants to stay even though the workflow moved on).
|
||||
pinnedSessionId: string | null;
|
||||
};
|
||||
|
||||
export type KanbanSliceState = {
|
||||
@@ -90,6 +96,10 @@ export type KanbanSliceActions = {
|
||||
reorderWorkflowItems: (workflowIds: string[]) => void;
|
||||
setActiveTask: (taskId: string) => void;
|
||||
setActiveSession: (taskId: string, sessionId: string) => void;
|
||||
// setActiveSessionAuto is the same as setActiveSession but doesn't update
|
||||
// pinnedSessionId. Used by WS handlers to follow workflow-driven session
|
||||
// switches without overriding a user's manual selection.
|
||||
setActiveSessionAuto: (taskId: string, sessionId: string) => void;
|
||||
clearActiveSession: () => void;
|
||||
setWorkflowSnapshot: (workflowId: string, data: WorkflowSnapshotData) => void;
|
||||
setKanbanMultiLoading: (loading: boolean) => void;
|
||||
|
||||
@@ -369,6 +369,7 @@ export type AppState = {
|
||||
) => void;
|
||||
setMessagesLoading: (sessionId: string, loading: boolean) => void;
|
||||
setActiveSession: (taskId: string, sessionId: string) => void;
|
||||
setActiveSessionAuto: (taskId: string, sessionId: string) => void;
|
||||
setActiveTask: (taskId: string) => void;
|
||||
clearActiveSession: () => void;
|
||||
setTaskSession: (session: TaskSession) => void;
|
||||
|
||||
@@ -11,12 +11,13 @@ import type { TaskSessionState } from "@/lib/types/http";
|
||||
|
||||
function makeStore(overrides: Record<string, unknown> = {}) {
|
||||
const state: Record<string, unknown> = {
|
||||
tasks: { activeTaskId: null, activeSessionId: null },
|
||||
tasks: { activeTaskId: null, activeSessionId: null, pinnedSessionId: null },
|
||||
taskSessions: { items: {} },
|
||||
taskSessionsByTask: { itemsByTaskId: {} },
|
||||
setTaskSession: vi.fn(),
|
||||
setTaskSessionsForTask: vi.fn(),
|
||||
setActiveSession: vi.fn(),
|
||||
setActiveSessionAuto: vi.fn(),
|
||||
setSessionFailureNotification: vi.fn(),
|
||||
setContextWindow: vi.fn(),
|
||||
...overrides,
|
||||
@@ -133,7 +134,7 @@ describe("session.state_changed handler", () => {
|
||||
|
||||
function makeAppState(partial: Partial<AppState>): AppState {
|
||||
return {
|
||||
tasks: { activeTaskId: null, activeSessionId: null },
|
||||
tasks: { activeTaskId: null, activeSessionId: null, pinnedSessionId: null },
|
||||
taskSessions: { items: {} },
|
||||
taskSessionsByTask: { itemsByTaskId: {} },
|
||||
...partial,
|
||||
@@ -158,14 +159,14 @@ describe("isTerminalSessionState", () => {
|
||||
describe("shouldAdoptNewSession", () => {
|
||||
it("adopts when there is no active session for the task", () => {
|
||||
const state = makeAppState({
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: null },
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: null, pinnedSessionId: null },
|
||||
});
|
||||
expect(shouldAdoptNewSession(state, "t-1", "STARTING")).toBe(true);
|
||||
});
|
||||
|
||||
it("adopts when active session belongs to a different task", () => {
|
||||
const state = makeAppState({
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-other" },
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-other", pinnedSessionId: null },
|
||||
taskSessions: {
|
||||
items: { "s-other": { id: "s-other", task_id: "t-2", state: "RUNNING" } },
|
||||
} as unknown as AppState["taskSessions"],
|
||||
@@ -175,7 +176,7 @@ describe("shouldAdoptNewSession", () => {
|
||||
|
||||
it("adopts when active session is already terminal", () => {
|
||||
const state = makeAppState({
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-old" },
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-old", pinnedSessionId: null },
|
||||
taskSessions: {
|
||||
items: { "s-old": { id: "s-old", task_id: "t-1", state: "COMPLETED" } },
|
||||
} as unknown as AppState["taskSessions"],
|
||||
@@ -185,7 +186,7 @@ describe("shouldAdoptNewSession", () => {
|
||||
|
||||
it("does NOT adopt while the current active session is still running", () => {
|
||||
const state = makeAppState({
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-old" },
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-old", pinnedSessionId: null },
|
||||
taskSessions: {
|
||||
items: { "s-old": { id: "s-old", task_id: "t-1", state: "RUNNING" } },
|
||||
} as unknown as AppState["taskSessions"],
|
||||
@@ -195,14 +196,14 @@ describe("shouldAdoptNewSession", () => {
|
||||
|
||||
it("does NOT adopt when the event is for a non-active task", () => {
|
||||
const state = makeAppState({
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: null },
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: null, pinnedSessionId: null },
|
||||
});
|
||||
expect(shouldAdoptNewSession(state, "t-2", "STARTING")).toBe(false);
|
||||
});
|
||||
|
||||
it("does NOT adopt terminal state events", () => {
|
||||
const state = makeAppState({
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: null },
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: null, pinnedSessionId: null },
|
||||
});
|
||||
expect(shouldAdoptNewSession(state, "t-1", "COMPLETED")).toBe(false);
|
||||
});
|
||||
@@ -250,7 +251,7 @@ describe("session.state_changed → active session switching", () => {
|
||||
|
||||
it("adopts a newly-created session for the active task", () => {
|
||||
const store = makeStore({
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: null },
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: null, pinnedSessionId: null },
|
||||
});
|
||||
const handler = registerTaskSessionHandlers(store)[STATE_CHANGED_EVENT]!;
|
||||
|
||||
@@ -261,12 +262,13 @@ describe("session.state_changed → active session switching", () => {
|
||||
payload: { task_id: "t-1", session_id: "s-new", new_state: "STARTING" },
|
||||
});
|
||||
|
||||
expect(store.getState().setActiveSession).toHaveBeenCalledWith("t-1", "s-new");
|
||||
expect(store.getState().setActiveSessionAuto).toHaveBeenCalledWith("t-1", "s-new");
|
||||
expect(store.getState().setActiveSession).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("does not adopt a new session for a task that is not active", () => {
|
||||
const store = makeStore({
|
||||
tasks: { activeTaskId: "other-task", activeSessionId: null },
|
||||
tasks: { activeTaskId: "other-task", activeSessionId: null, pinnedSessionId: null },
|
||||
});
|
||||
const handler = registerTaskSessionHandlers(store)[STATE_CHANGED_EVENT]!;
|
||||
|
||||
@@ -277,12 +279,12 @@ describe("session.state_changed → active session switching", () => {
|
||||
payload: { task_id: "t-1", session_id: "s-new", new_state: "STARTING" },
|
||||
});
|
||||
|
||||
expect(store.getState().setActiveSession).not.toHaveBeenCalled();
|
||||
expect(store.getState().setActiveSessionAuto).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("does not adopt while the current active session is still running", () => {
|
||||
const store = makeStore({
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-old" },
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-old", pinnedSessionId: null },
|
||||
taskSessions: {
|
||||
items: { "s-old": { id: "s-old", task_id: "t-1", state: "RUNNING" } },
|
||||
},
|
||||
@@ -296,7 +298,33 @@ describe("session.state_changed → active session switching", () => {
|
||||
payload: { task_id: "t-1", session_id: "s-new", new_state: "STARTING" },
|
||||
});
|
||||
|
||||
expect(store.getState().setActiveSession).not.toHaveBeenCalled();
|
||||
expect(store.getState().setActiveSessionAuto).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
// Regression for the reverse-event-ordering race: if the OLD pinned session's
|
||||
// COMPLETED event arrives before the NEW session's STARTING event, the
|
||||
// terminal-handoff guard (which protects pinning) doesn't run on the COMPLETED
|
||||
// event because s-new isn't yet in the store. When the STARTING event
|
||||
// arrives, shouldAdoptNewSession returns true (old is now terminal) and would
|
||||
// auto-yank the user off their pinned session — unless we re-check pinning on
|
||||
// this path too.
|
||||
it("does not yank a pinned session on reverse event ordering (old COMPLETED, then new STARTING)", () => {
|
||||
const store = makeStore({
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-old", pinnedSessionId: "s-old" },
|
||||
taskSessions: {
|
||||
items: { "s-old": { id: "s-old", task_id: "t-1", state: "COMPLETED" } },
|
||||
},
|
||||
});
|
||||
const handler = registerTaskSessionHandlers(store)[STATE_CHANGED_EVENT]!;
|
||||
|
||||
handler({
|
||||
id: "m",
|
||||
type: "notification",
|
||||
action: STATE_CHANGED_EVENT,
|
||||
payload: { task_id: "t-1", session_id: "s-new", new_state: "STARTING" },
|
||||
});
|
||||
|
||||
expect(store.getState().setActiveSessionAuto).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
@@ -307,7 +335,7 @@ describe("session.state_changed → active session handoff on terminal", () => {
|
||||
|
||||
it("hands off when the current active session transitions to terminal", () => {
|
||||
const store = makeStore({
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-old" },
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-old", pinnedSessionId: null },
|
||||
taskSessions: {
|
||||
items: { "s-old": { id: "s-old", task_id: "t-1", state: "RUNNING" } },
|
||||
},
|
||||
@@ -329,7 +357,8 @@ describe("session.state_changed → active session handoff on terminal", () => {
|
||||
payload: { task_id: "t-1", session_id: "s-old", new_state: "COMPLETED" },
|
||||
});
|
||||
|
||||
expect(store.getState().setActiveSession).toHaveBeenCalledWith("t-1", "s-new");
|
||||
expect(store.getState().setActiveSessionAuto).toHaveBeenCalledWith("t-1", "s-new");
|
||||
expect(store.getState().setActiveSession).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
// The per-task list here still shows s-old as RUNNING (pre-event state), so
|
||||
@@ -338,7 +367,7 @@ describe("session.state_changed → active session handoff on terminal", () => {
|
||||
// to the same session that just became terminal.
|
||||
it("does not hand off when the only candidate is the terminating session itself", () => {
|
||||
const store = makeStore({
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-old" },
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-old", pinnedSessionId: null },
|
||||
taskSessions: {
|
||||
items: { "s-old": { id: "s-old", task_id: "t-1", state: "RUNNING" } },
|
||||
},
|
||||
@@ -359,12 +388,12 @@ describe("session.state_changed → active session handoff on terminal", () => {
|
||||
payload: { task_id: "t-1", session_id: "s-old", new_state: "COMPLETED" },
|
||||
});
|
||||
|
||||
expect(store.getState().setActiveSession).not.toHaveBeenCalled();
|
||||
expect(store.getState().setActiveSessionAuto).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("does not hand off when all other sessions for the task are terminal", () => {
|
||||
const store = makeStore({
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-old" },
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-old", pinnedSessionId: null },
|
||||
taskSessions: {
|
||||
items: { "s-old": { id: "s-old", task_id: "t-1", state: "RUNNING" } },
|
||||
},
|
||||
@@ -386,6 +415,42 @@ describe("session.state_changed → active session handoff on terminal", () => {
|
||||
payload: { task_id: "t-1", session_id: "s-old", new_state: "COMPLETED" },
|
||||
});
|
||||
|
||||
expect(store.getState().setActiveSessionAuto).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe("session.state_changed → respects user-pinned session", () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
});
|
||||
|
||||
it("does NOT hand off when the user pinned the session that just terminated", () => {
|
||||
// User manually clicked s-old, so pinnedSessionId === "s-old".
|
||||
// When s-old terminates we should respect the pin and stay on it.
|
||||
const store = makeStore({
|
||||
tasks: { activeTaskId: "t-1", activeSessionId: "s-old", pinnedSessionId: "s-old" },
|
||||
taskSessions: {
|
||||
items: { "s-old": { id: "s-old", task_id: "t-1", state: "RUNNING" } },
|
||||
},
|
||||
taskSessionsByTask: {
|
||||
itemsByTaskId: {
|
||||
"t-1": [
|
||||
{ id: "s-old", task_id: "t-1", state: "RUNNING", started_at: "", updated_at: "" },
|
||||
{ id: "s-new", task_id: "t-1", state: "STARTING", started_at: "", updated_at: "" },
|
||||
],
|
||||
},
|
||||
},
|
||||
});
|
||||
const handler = registerTaskSessionHandlers(store)[STATE_CHANGED_EVENT]!;
|
||||
|
||||
handler({
|
||||
id: "m",
|
||||
type: "notification",
|
||||
action: STATE_CHANGED_EVENT,
|
||||
payload: { task_id: "t-1", session_id: "s-old", new_state: "COMPLETED" },
|
||||
});
|
||||
|
||||
expect(store.getState().setActiveSessionAuto).not.toHaveBeenCalled();
|
||||
expect(store.getState().setActiveSession).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
@@ -171,17 +171,28 @@ function maybeAdoptSessionOnTransition(
|
||||
|
||||
if (!wasKnownToStore && shouldAdoptNewSession(state, taskId, newState)) {
|
||||
const oldSessionId = state.tasks.activeSessionId;
|
||||
// Reverse-ordering guard: if the events arrive as old=COMPLETED then
|
||||
// new=STARTING (instead of the typical new=STARTING then old=COMPLETED),
|
||||
// shouldAdoptNewSession returns true on the second event because the old
|
||||
// session is now terminal. But the user may have pinned the old session —
|
||||
// in that case the symmetric guard below was skipped (no terminal event
|
||||
// for the new session), and we'd auto-yank them off their pinned session
|
||||
// here. Match the terminal-handoff path's pinning check.
|
||||
if (oldSessionId && state.tasks.pinnedSessionId === oldSessionId) return;
|
||||
if (oldSessionId) inheritAgentctlStatus(state, oldSessionId, sessionId);
|
||||
state.setActiveSession(taskId, sessionId);
|
||||
state.setActiveSessionAuto(taskId, sessionId);
|
||||
return;
|
||||
}
|
||||
|
||||
const isActive = state.tasks.activeSessionId === sessionId;
|
||||
if (isActive && newState && isTerminalSessionState(newState)) {
|
||||
// If the user explicitly pinned this session (manual click), don't yank
|
||||
// them away just because the workflow moved it to a terminal state.
|
||||
if (state.tasks.pinnedSessionId === sessionId) return;
|
||||
const replacement = pickReplacementSessionId(state, taskId);
|
||||
if (replacement && replacement !== sessionId) {
|
||||
inheritAgentctlStatus(state, sessionId, replacement);
|
||||
state.setActiveSession(taskId, replacement);
|
||||
state.setActiveSessionAuto(taskId, replacement);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,179 @@
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import type { StoreApi } from "zustand";
|
||||
import type { AppState } from "@/lib/state/store";
|
||||
import { registerTasksHandlers } from "./tasks";
|
||||
|
||||
type Listener = (state: AppState) => void;
|
||||
|
||||
/**
|
||||
* Minimal in-memory store for the tasks WS handler tests.
|
||||
* The handler reads kanban tasks, kanbanMulti snapshots, and tasks.activeTaskId/activeSessionId,
|
||||
* and calls setActiveSession; everything else can stay default.
|
||||
*/
|
||||
function makeStore(initial: Partial<AppState> = {}) {
|
||||
let state = {
|
||||
kanban: { workflowId: "wf1", steps: [], tasks: [] },
|
||||
kanbanMulti: { snapshots: {}, isLoading: false },
|
||||
tasks: { activeTaskId: null, activeSessionId: null, pinnedSessionId: null },
|
||||
setActiveSession: vi.fn((taskId: string, sessionId: string | null) => {
|
||||
state = {
|
||||
...state,
|
||||
tasks: {
|
||||
activeTaskId: taskId,
|
||||
activeSessionId: sessionId,
|
||||
pinnedSessionId: sessionId,
|
||||
},
|
||||
};
|
||||
}),
|
||||
setActiveSessionAuto: vi.fn((taskId: string, sessionId: string | null) => {
|
||||
state = {
|
||||
...state,
|
||||
tasks: {
|
||||
...state.tasks,
|
||||
activeTaskId: taskId,
|
||||
activeSessionId: sessionId,
|
||||
},
|
||||
};
|
||||
}),
|
||||
...initial,
|
||||
} as unknown as AppState;
|
||||
|
||||
const listeners = new Set<Listener>();
|
||||
return {
|
||||
getState: () => state,
|
||||
setState: (updater: AppState | ((s: AppState) => AppState)) => {
|
||||
const next =
|
||||
typeof updater === "function" ? (updater as (s: AppState) => AppState)(state) : updater;
|
||||
state = { ...state, ...next };
|
||||
for (const l of listeners) l(state);
|
||||
},
|
||||
subscribe: (l: Listener) => {
|
||||
listeners.add(l);
|
||||
return () => listeners.delete(l);
|
||||
},
|
||||
destroy: vi.fn(),
|
||||
getInitialState: vi.fn(),
|
||||
} as unknown as StoreApi<AppState> & { getState: () => AppState };
|
||||
}
|
||||
|
||||
function makeTask(id: string, primarySessionId: string | null, workflowId = "wf1") {
|
||||
return {
|
||||
task_id: id,
|
||||
workflow_id: workflowId,
|
||||
workflow_step_id: "step1",
|
||||
title: "Test",
|
||||
description: "",
|
||||
state: "IN_PROGRESS",
|
||||
primary_session_id: primarySessionId,
|
||||
is_ephemeral: false,
|
||||
} as Record<string, unknown>;
|
||||
}
|
||||
|
||||
function makeMessage(payload: Record<string, unknown>) {
|
||||
return {
|
||||
id: "msg-1",
|
||||
type: "notification" as const,
|
||||
action: "task.updated" as const,
|
||||
payload,
|
||||
} as Parameters<NonNullable<ReturnType<typeof registerTasksHandlers>["task.updated"]>>[0];
|
||||
}
|
||||
|
||||
describe("task.updated primary-session focus follow", () => {
|
||||
let store: ReturnType<typeof makeStore>;
|
||||
let setActiveSessionAuto: ReturnType<typeof vi.fn>;
|
||||
|
||||
beforeEach(() => {
|
||||
setActiveSessionAuto = vi.fn();
|
||||
});
|
||||
|
||||
it("follows focus to the new primary when the user is on the previous primary", () => {
|
||||
store = makeStore({
|
||||
kanban: {
|
||||
workflowId: "wf1",
|
||||
steps: [],
|
||||
tasks: [{ id: "t1", primarySessionId: "sess-old", workflowId: "wf1" }],
|
||||
} as unknown as AppState["kanban"],
|
||||
tasks: { activeTaskId: "t1", activeSessionId: "sess-old", pinnedSessionId: null },
|
||||
setActiveSessionAuto,
|
||||
});
|
||||
|
||||
const handlers = registerTasksHandlers(store);
|
||||
handlers["task.updated"]!(makeMessage(makeTask("t1", "sess-new")));
|
||||
|
||||
expect(setActiveSessionAuto).toHaveBeenCalledTimes(1);
|
||||
expect(setActiveSessionAuto).toHaveBeenCalledWith("t1", "sess-new");
|
||||
});
|
||||
|
||||
it("does NOT follow focus when the user is on a different session than the previous primary", () => {
|
||||
// User manually selected sess-other; primary swapping shouldn't yank them away.
|
||||
store = makeStore({
|
||||
kanban: {
|
||||
workflowId: "wf1",
|
||||
steps: [],
|
||||
tasks: [{ id: "t1", primarySessionId: "sess-old", workflowId: "wf1" }],
|
||||
} as unknown as AppState["kanban"],
|
||||
tasks: { activeTaskId: "t1", activeSessionId: "sess-other", pinnedSessionId: "sess-other" },
|
||||
setActiveSessionAuto,
|
||||
});
|
||||
|
||||
const handlers = registerTasksHandlers(store);
|
||||
handlers["task.updated"]!(makeMessage(makeTask("t1", "sess-new")));
|
||||
|
||||
expect(setActiveSessionAuto).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("does NOT follow focus when the user is viewing a different task", () => {
|
||||
store = makeStore({
|
||||
kanban: {
|
||||
workflowId: "wf1",
|
||||
steps: [],
|
||||
tasks: [{ id: "t1", primarySessionId: "sess-old", workflowId: "wf1" }],
|
||||
} as unknown as AppState["kanban"],
|
||||
tasks: { activeTaskId: "t2", activeSessionId: "sess-old", pinnedSessionId: null },
|
||||
setActiveSessionAuto,
|
||||
});
|
||||
|
||||
const handlers = registerTasksHandlers(store);
|
||||
handlers["task.updated"]!(makeMessage(makeTask("t1", "sess-new")));
|
||||
|
||||
expect(setActiveSessionAuto).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("does NOT call setActiveSessionAuto when the primary did not change", () => {
|
||||
store = makeStore({
|
||||
kanban: {
|
||||
workflowId: "wf1",
|
||||
steps: [],
|
||||
tasks: [{ id: "t1", primarySessionId: "sess-old", workflowId: "wf1" }],
|
||||
} as unknown as AppState["kanban"],
|
||||
tasks: { activeTaskId: "t1", activeSessionId: "sess-old", pinnedSessionId: null },
|
||||
setActiveSessionAuto,
|
||||
});
|
||||
|
||||
const handlers = registerTasksHandlers(store);
|
||||
handlers["task.updated"]!(makeMessage(makeTask("t1", "sess-old")));
|
||||
|
||||
expect(setActiveSessionAuto).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
// Regression: even when the user happens to be sitting on the previous
|
||||
// primary, an explicit pin on it must override primary-follow-focus —
|
||||
// otherwise a workflow profile switch silently yanks them off the session
|
||||
// they deliberately clicked into.
|
||||
it("does NOT follow focus when the user has pinned the previous primary", () => {
|
||||
store = makeStore({
|
||||
kanban: {
|
||||
workflowId: "wf1",
|
||||
steps: [],
|
||||
tasks: [{ id: "t1", primarySessionId: "sess-old", workflowId: "wf1" }],
|
||||
} as unknown as AppState["kanban"],
|
||||
tasks: { activeTaskId: "t1", activeSessionId: "sess-old", pinnedSessionId: "sess-old" },
|
||||
setActiveSessionAuto,
|
||||
});
|
||||
|
||||
const handlers = registerTasksHandlers(store);
|
||||
handlers["task.updated"]!(makeMessage(makeTask("t1", "sess-new")));
|
||||
|
||||
expect(setActiveSessionAuto).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
@@ -64,6 +64,17 @@ function upsertTaskInBothKanbans(
|
||||
return next;
|
||||
}
|
||||
|
||||
/** Look up a task across both single-kanban and multi-kanban snapshots. */
|
||||
function findTaskInState(state: AppState, taskId: string): KanbanTask | undefined {
|
||||
const fromKanban = state.kanban.tasks.find((t) => t.id === taskId);
|
||||
if (fromKanban) return fromKanban;
|
||||
for (const snapshot of Object.values(state.kanbanMulti.snapshots)) {
|
||||
const found = snapshot.tasks.find((t) => t.id === taskId);
|
||||
if (found) return found;
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
/** Remove a task from both single-kanban and multi-kanban snapshots. */
|
||||
function removeTaskFromBothKanbans(state: AppState, wfId: string, taskId: string): AppState {
|
||||
let next = state;
|
||||
@@ -102,9 +113,15 @@ export function registerTasksHandlers(store: StoreApi<AppState>): WsHandlers {
|
||||
// Skip ephemeral tasks (e.g., quick chat) - they shouldn't appear on the Kanban board
|
||||
if (message.payload.is_ephemeral) return;
|
||||
|
||||
// Capture the previous primary session id BEFORE the upsert so we can
|
||||
// detect a primary-session swap (e.g. workflow profile switch reusing a
|
||||
// different session) and follow focus to the new primary.
|
||||
const beforeState = store.getState();
|
||||
const taskId = message.payload.task_id;
|
||||
const previousPrimary = findTaskInState(beforeState, taskId)?.primarySessionId ?? null;
|
||||
|
||||
store.setState((state) => {
|
||||
const wfId = message.payload.workflow_id;
|
||||
const taskId = message.payload.task_id;
|
||||
|
||||
if (message.payload.archived_at) {
|
||||
return removeTaskFromBothKanbans(state, wfId, taskId);
|
||||
@@ -112,6 +129,26 @@ export function registerTasksHandlers(store: StoreApi<AppState>): WsHandlers {
|
||||
|
||||
return upsertTaskInBothKanbans(state, wfId, message.payload);
|
||||
});
|
||||
|
||||
// Follow focus to the new primary when:
|
||||
// - the user is currently viewing this task,
|
||||
// - the user was sitting on the previous primary,
|
||||
// - they did NOT explicitly pin that previous primary (a manual click
|
||||
// sets pinnedSessionId; pinned sessions must be left alone), and
|
||||
// - the primary actually changed.
|
||||
// This makes workflow profile switches transparent for unpinned users
|
||||
// without yanking pinned ones off their deliberate selection.
|
||||
const afterState = store.getState();
|
||||
const newPrimary = findTaskInState(afterState, taskId)?.primarySessionId ?? null;
|
||||
if (
|
||||
newPrimary &&
|
||||
newPrimary !== previousPrimary &&
|
||||
afterState.tasks.activeTaskId === taskId &&
|
||||
afterState.tasks.activeSessionId === previousPrimary &&
|
||||
afterState.tasks.pinnedSessionId !== previousPrimary
|
||||
) {
|
||||
afterState.setActiveSessionAuto(taskId, newPrimary);
|
||||
}
|
||||
},
|
||||
"task.deleted": (message) => {
|
||||
const deletedId = message.payload.task_id;
|
||||
|
||||
Reference in New Issue
Block a user