fix: resolve goal completion deadlock and paused→achieved transition

Three bugs fixed:

1. Agent deadlock: the pending-tasks guard blocked `achieved` when the
   agent's own [auto] task was in_progress — autonomous tasks are now
   excluded from the check since they are the mechanism for achieving
   the goal, not a blocker.

2. State machine: added `paused → achieved` transition so goals can be
   completed directly from paused state.

3. TUI: C-key now passes `{ force: true }` to cancel cancellable pending
   tasks, with an informative message. Callback signature updated to
   forward opts through to GoalService.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: oxgeneral

src/application/goal-service.ts

@@ -2,8 +2,8 @@
  * Goal service — business logic for goal lifecycle.
  *
  * Goals are persistent objectives that drive autonomous agent work.
- * State machine: active → achieved | abandoned
- *                active ↔ paused
+ * State machine: active → achieved | abandoned | paused
+ *                paused → active | achieved | abandoned
  *
  * Side effect: assigning an agent to a goal auto-enables autonomous mode;
  * removing the last active goal from an agent auto-disables it.
@@ -22,7 +22,7 @@ import type { TaskService } from './task-service.js';
 
 const VALID_TRANSITIONS: Record<GoalStatus, GoalStatus[]> = {
   active: ['paused', 'achieved', 'abandoned'],
-  paused: ['active', 'abandoned'],
+  paused: ['active', 'achieved', 'abandoned'],
   achieved: [],
   abandoned: [],
 };
@@ -82,10 +82,14 @@ export class GoalService {
       );
     }
 
-    // Guard: block achieved if child tasks are still pending
+    // Guard: block achieved if child tasks are still pending.
+    // Autonomous [auto] tasks are excluded — they are the mechanism for achieving
+    // the goal and will be cleaned up by side effects after status change.
     if (newStatus === 'achieved' && this.taskService) {
       const childTasks = await this.taskService.list({ goalId: id });
-      const pending = childTasks.filter((t) => !isTaskTerminal(t.status));
+      const pending = childTasks.filter(
+        (t) => !isTaskTerminal(t.status) && !t.labels?.includes(AUTONOMOUS_LABEL),
+      );
       if (pending.length > 0) {
         if (opts?.force) {
           // Force mode: cancel tasks that are safe to cancel at storage level.

src/cli/commands/tui.ts

@@ -207,8 +207,8 @@ export function registerTuiCommand(program: Command, container: Container): void
         return container.goalService.update(id, fields);
       };
 
-      const onUpdateGoalStatus = async (id: string, status: import('../../domain/goal.js').GoalStatus) => {
-        return container.goalService.updateStatus(id, status);
+      const onUpdateGoalStatus = async (id: string, status: import('../../domain/goal.js').GoalStatus, opts?: { force?: boolean }) => {
+        return container.goalService.updateStatus(id, status, opts);
       };
 
       const onDeleteGoal = async (id: string) => {

src/domain/goal.ts

@@ -5,8 +5,8 @@
  * Goals have lower priority than tasks — agents work on goals only
  * when no regular tasks are available.
  *
- * State machine: active → achieved | abandoned
- *                active ↔ paused
+ * State machine: active → achieved | abandoned | paused
+ *                paused → active | achieved | abandoned
  */
 
 export const GOAL_STATUSES = ['active', 'paused', 'achieved', 'abandoned'] as const;

src/tui/App.tsx

@@ -182,7 +182,7 @@ export interface AppProps {
   onRefreshGoals?: () => Promise<Goal[]>;
   onCreateGoal?: (input: { title: string; description?: string; assignee?: string }) => Promise<Goal>;
   onUpdateGoal?: (id: string, fields: { title?: string; description?: string; assignee?: string }) => Promise<Goal>;
-  onUpdateGoalStatus?: (id: string, status: GoalStatus) => Promise<Goal>;
+  onUpdateGoalStatus?: (id: string, status: GoalStatus, opts?: { force?: boolean }) => Promise<Goal>;
   onDeleteGoal?: (id: string) => Promise<void>;
   onGetGoalProgress?: (goalId: string) => Promise<string | undefined>;
   /** Callback to persist onboardingCompleted=true when onboarding finishes */
@@ -2038,11 +2038,11 @@ export function App({
       return;
     }
 
-    // C: mark goal as achieved / abandon
+    // C: mark goal as achieved (force: cancel cancellable pending tasks)
     if ((input === 'c' || input === 'C') && activeView === 'goals' && selectedGoal && onUpdateGoalStatus) {
       if (selectedGoal.status === 'active' || selectedGoal.status === 'paused') {
-        addMessage(`Marking goal "${selectedGoal.title}" as achieved...`, tuiColors.amber);
-        onUpdateGoalStatus(selectedGoal.id, 'achieved').then(
+        addMessage(`Marking goal "${selectedGoal.title}" as achieved (pending tasks will be cancelled)...`, tuiColors.amber);
+        onUpdateGoalStatus(selectedGoal.id, 'achieved', { force: true }).then(
           () => { addMessage(`\u2713 Goal "${selectedGoal.title}" achieved`, tuiColors.green); refreshAll(); },
           (err) => addMessage(`Failed: ${err instanceof Error ? err.message : String(err)}`, tuiColors.red),
         );

test/unit/application/goal-service-autonomous.test.ts

@@ -447,6 +447,64 @@ describe('GoalService autonomous mode side effects', () => {
       }
     });
 
+    it('excludes autonomous [auto] tasks from pending check', async () => {
+      const goal = makeGoal({ id: 'goal_auto1', status: 'active', assignee: 'agt_a' });
+      const tasks = [
+        makeTask({ id: 'tsk_auto', status: 'in_progress', goalId: 'goal_auto1', labels: ['autonomous'] }),
+        makeTask({ id: 'tsk_done', status: 'done', goalId: 'goal_auto1' }),
+      ];
+      const goalStore = createMockGoalStore([goal]);
+      const agentService = createMockAgentService();
+      const taskService = createMockTaskService(tasks);
+      const svc = new GoalService(goalStore, eventBus, agentService as any, taskService as any);
+
+      // The [auto] task is in_progress but should be excluded — no deadlock
+      const result = await svc.updateStatus('goal_auto1', 'achieved');
+      expect(result.status).toBe('achieved');
+    });
+
+    it('still blocks on non-autonomous in_progress tasks', async () => {
+      const goal = makeGoal({ id: 'goal_block', status: 'active' });
+      const tasks = [
+        makeTask({ id: 'tsk_auto', status: 'in_progress', goalId: 'goal_block', labels: ['autonomous'] }),
+        makeTask({ id: 'tsk_user', status: 'in_progress', goalId: 'goal_block', labels: [] }),
+      ];
+      const goalStore = createMockGoalStore([goal]);
+      const taskService = createMockTaskService(tasks);
+      const svc = new GoalService(goalStore, eventBus, undefined, taskService as any);
+
+      await expect(svc.updateStatus('goal_block', 'achieved'))
+        .rejects.toThrow(GoalHasPendingTasksError);
+    });
+
+    it('paused → achieved is allowed and calls maybeDisableAutonomous', async () => {
+      const goal = makeGoal({ id: 'goal_pa1', status: 'paused', assignee: 'agt_pa' });
+      const goalStore = createMockGoalStore([goal]);
+      const agentService = createMockAgentService();
+      const taskService = createMockTaskService([]);
+      const svc = new GoalService(goalStore, eventBus, agentService as any, taskService as any);
+
+      const result = await svc.updateStatus('goal_pa1', 'achieved');
+      expect(result.status).toBe('achieved');
+      expect(agentService.setAutonomous).toHaveBeenCalledWith('agt_pa', false);
+    });
+
+    it('paused → achieved with force cancels pending non-auto tasks', async () => {
+      const goal = makeGoal({ id: 'goal_pf1', status: 'paused' });
+      const tasks = [
+        makeTask({ id: 'tsk_pf1', status: 'todo', goalId: 'goal_pf1' }),
+        makeTask({ id: 'tsk_pf2', status: 'review', goalId: 'goal_pf1' }),
+      ];
+      const goalStore = createMockGoalStore([goal]);
+      const taskService = createMockTaskService(tasks);
+      const svc = new GoalService(goalStore, eventBus, undefined, taskService as any);
+
+      const result = await svc.updateStatus('goal_pf1', 'achieved', { force: true });
+      expect(result.status).toBe('achieved');
+      expect(taskService.cancel).toHaveBeenCalledWith('tsk_pf1');
+      expect(taskService.cancel).toHaveBeenCalledWith('tsk_pf2');
+    });
+
     it('skips validation when taskService is not provided', async () => {
       const goal = makeGoal({ id: 'goal_notsk', status: 'active' });
       const goalStore = createMockGoalStore([goal]);