Track session context changes during task execution

package.json

@@ -15,7 +15,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@github/copilot-sdk": "^0.1.0",
+    "@github/copilot-sdk": "^0.1.24",
     "ink": "^5.1.0",
     "ink-select-input": "^6.0.0",
     "ink-spinner": "^5.0.0",

src/screens/execute.tsx

@@ -2,7 +2,7 @@ import React, { useState, useEffect, useRef } from 'react';
 import { Box, Text, useInput } from 'ink';
 import type { Plan, Task } from '../models/plan.js';
 import { executePlan } from '../services/executor.js';
-import type { ExecutionOptions, ExecutionHandle } from '../services/executor.js';
+import type { ExecutionOptions, ExecutionHandle, SessionEventWithTask } from '../services/executor.js';
 import { savePlan, summarizePlan } from '../services/persistence.js';
 import { computeBatches } from '../utils/dependency-graph.js';
 import Spinner from '../components/spinner.js';
@@ -46,6 +46,8 @@ export default function ExecuteScreen({
   const [runCount, setRunCount] = useState(0); // incremented to re-trigger execution
   const execHandleRef = useRef<ExecutionHandle | null>(null);
   const [summarized, setSummarized] = useState('');
+  const [sessionEvents, setSessionEvents] = useState<SessionEventWithTask[]>([]);
+  const [taskContexts, setTaskContexts] = useState<Record<string, { cwd?: string; repository?: string; branch?: string }>>({});
 
   const { batches } = computeBatches(plan.tasks);
   // Total display batches: init batch (index 0) + real batches
@@ -195,6 +197,32 @@ export default function ExecuteScreen({
         }
         // Otherwise stay on execute screen — user can press 'r' to retry
       },
+      onSessionEvent: (eventWithTask) => {
+        const { event, taskId } = eventWithTask;
+
+        // Only store session events that we actually render / use, and keep history bounded
+        if (event.type === 'session.context_changed') {
+          const { cwd, repository, branch } = event.data;
+          setSessionEvents((prev) => {
+            const updated = [...prev, eventWithTask];
+            return updated.slice(-100); // Keep last 100 events
+          });
+          setTaskContexts((prev) => ({
+            ...prev,
+            [taskId]: { cwd, repository, branch },
+          }));
+        } else if (event.type === 'session.start' && event.data.context) {
+          const { cwd, repository, branch } = event.data.context;
+          setSessionEvents((prev) => {
+            const updated = [...prev, eventWithTask];
+            return updated.slice(-100); // Keep last 100 events
+          });
+          setTaskContexts((prev) => ({
+            ...prev,
+            [taskId]: { cwd, repository, branch },
+          }));
+        }
+      },
     }, execOptions);
 
     execHandleRef.current = handle;
@@ -318,18 +346,29 @@ export default function ExecuteScreen({
             const isSelected = i === selectedTaskIndex;
             const icon = STATUS_ICON[task.status] ?? '?';
             const color = STATUS_COLOR[task.status] ?? 'gray';
+            const context = taskContexts[task.id];
             return (
-              <Box key={task.id}>
-                <Text color={isSelected ? 'white' : 'gray'}>{isSelected ? '❯ ' : '  '}</Text>
-                <Text color={color}>{icon} </Text>
-                <Text color={isSelected ? 'white' : color} bold={isSelected}>
-                  {task.id}
-                </Text>
-                <Text color="gray"> — {task.title}</Text>
-                {task.status === 'in_progress' && (
-                  <Text color="yellow"> </Text>
+              <Box key={task.id} flexDirection="column">
+                <Box>
+                  <Text color={isSelected ? 'white' : 'gray'}>{isSelected ? '❯ ' : '  '}</Text>
+                  <Text color={color}>{icon} </Text>
+                  <Text color={isSelected ? 'white' : color} bold={isSelected}>
+                    {task.id}
+                  </Text>
+                  <Text color="gray"> — {task.title}</Text>
+                  {task.status === 'in_progress' && (
+                    <Text color="yellow"> </Text>
+                  )}
+                  {task.status === 'in_progress' && <Spinner />}
+                </Box>
+                {context?.cwd && (
+                  <Box marginLeft={4}>
+                    <Text color="cyan" dimColor>📁 {context.cwd}</Text>
+                    {context.repository && (
+                      <Text color="blue" dimColor> ({context.repository})</Text>
+                    )}
+                  </Box>
                 )}
-                {task.status === 'in_progress' && <Spinner />}
               </Box>
             );
           })}
@@ -376,6 +415,32 @@ export default function ExecuteScreen({
         </Box>
       )}
 
+      {/* Context change events for selected task */}
+      {started && selectedTask && (() => {
+        const taskEvents = sessionEvents.filter(
+          (e) => e.taskId === selectedTask.id && e.event.type === 'session.context_changed'
+        );
+        if (taskEvents.length === 0) return null;
+
+        return (
+          <Box flexDirection="column" marginLeft={1} marginBottom={1}>
+            <Text color="cyan" bold>Context Changes:</Text>
+            {taskEvents.slice(-3).map((e) => {
+              if (e.event.type !== 'session.context_changed') return null;
+              const time = new Date(e.event.timestamp).toLocaleTimeString();
+              const { cwd, repository, branch } = e.event.data;
+              return (
+                <Box key={e.event.id}>
+                  <Text color="gray">{time} </Text>
+                  <Text color="cyan">→ {cwd}</Text>
+                  {repository && <Text color="blue"> ({repository}{branch ? `@${branch}` : ''})</Text>}
+                </Box>
+              );
+            })}
+          </Box>
+        );
+      })()}
+
       {/* Retry prompt when there are failures */}
       {started && !executing && failedCount > 0 && (
         <Box marginBottom={1}>

src/services/copilot.ts

@@ -1,9 +1,13 @@
 import { CopilotClient } from '@github/copilot-sdk';
+import type { SessionEvent } from '@github/copilot-sdk';
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { existsSync } from 'node:fs';
 import type { ChatMessage } from '../models/plan.js';
 
+// Re-export SessionEvent for use in other modules
+export type { SessionEvent };
+
 const SETTINGS_PATH = join(process.cwd(), '.planeteer', 'settings.json');
 
 interface Settings {
@@ -108,6 +112,7 @@ export interface StreamCallbacks {
   onDelta: (text: string) => void;
   onDone: (fullText: string) => void;
   onError: (error: Error) => void;
+  onSessionEvent?: (event: SessionEvent) => void;
 }
 
 export async function sendPrompt(
@@ -137,6 +142,17 @@ export async function sendPrompt(
   let fullText = '';
   let settled = false;
 
+  // Listen for session events if callback provided, but avoid forwarding
+  // high-volume delta events that are already handled by onDelta.
+  if (callbacks.onSessionEvent) {
+    session.on((event: SessionEvent) => {
+      if (event.type === 'assistant.message_delta') {
+        return;
+      }
+      callbacks.onSessionEvent?.(event);
+    });
+  }
+
   session.on('assistant.message_delta', (event: { data: { deltaContent: string } }) => {
     fullText += event.data.deltaContent;
     callbacks.onDelta(event.data.deltaContent);
@@ -176,10 +192,15 @@ export async function sendPrompt(
 export async function sendPromptSync(
   systemPrompt: string,
   messages: ChatMessage[],
-  options?: { timeoutMs?: number; onDelta?: (delta: string, fullText: string) => void },
+  options?: { 
+    timeoutMs?: number; 
+    onDelta?: (delta: string, fullText: string) => void;
+    onSessionEvent?: (event: SessionEvent) => void;
+  },
 ): Promise<string> {
   const idleTimeoutMs = options?.timeoutMs ?? 120_000;
   const onDelta = options?.onDelta;
+  const onSessionEvent = options?.onSessionEvent;
 
   return new Promise((resolve, reject) => {
     let settled = false;
@@ -235,6 +256,7 @@ export async function sendPromptSync(
           reject(err);
         }
       },
+      onSessionEvent,
     });
   });
 }