@xortex/xcode 3.0.1 → 3.0.2

package/state/onChangeAppState.ts

@@ -0,0 +1,171 @@
+import { setMainLoopModelOverride } from '../bootstrap/state.js'
+import {
+  clearApiKeyHelperCache,
+  clearAwsCredentialsCache,
+  clearGcpCredentialsCache,
+} from '../utils/auth.js'
+import { getGlobalConfig, saveGlobalConfig } from '../utils/config.js'
+import { toError } from '../utils/errors.js'
+import { logError } from '../utils/log.js'
+import { applyConfigEnvironmentVariables } from '../utils/managedEnv.js'
+import {
+  permissionModeFromString,
+  toExternalPermissionMode,
+} from '../utils/permissions/PermissionMode.js'
+import {
+  notifyPermissionModeChanged,
+  notifySessionMetadataChanged,
+  type SessionExternalMetadata,
+} from '../utils/sessionState.js'
+import { updateSettingsForSource } from '../utils/settings/settings.js'
+import type { AppState } from './AppStateStore.js'
+
+// Inverse of the push below — restore on worker restart.
+export function externalMetadataToAppState(
+  metadata: SessionExternalMetadata,
+): (prev: AppState) => AppState {
+  return prev => ({
+    ...prev,
+    ...(typeof metadata.permission_mode === 'string'
+      ? {
+          toolPermissionContext: {
+            ...prev.toolPermissionContext,
+            mode: permissionModeFromString(metadata.permission_mode),
+          },
+        }
+      : {}),
+    ...(typeof metadata.is_ultraplan_mode === 'boolean'
+      ? { isUltraplanMode: metadata.is_ultraplan_mode }
+      : {}),
+  })
+}
+
+export function onChangeAppState({
+  newState,
+  oldState,
+}: {
+  newState: AppState
+  oldState: AppState
+}) {
+  // toolPermissionContext.mode — single choke point for CCR/SDK mode sync.
+  //
+  // Prior to this block, mode changes were relayed to CCR by only 2 of 8+
+  // mutation paths: a bespoke setAppState wrapper in print.ts (headless/SDK
+  // mode only) and a manual notify in the set_permission_mode handler.
+  // Every other path — Shift+Tab cycling, ExitPlanModePermissionRequest
+  // dialog options, the /plan slash command, rewind, the REPL bridge's
+  // onSetPermissionMode — mutated AppState without telling
+  // CCR, leaving external_metadata.permission_mode stale and the web UI out
+  // of sync with the CLI's actual mode.
+  //
+  // Hooking the diff here means ANY setAppState call that changes the mode
+  // notifies CCR (via notifySessionMetadataChanged → ccrClient.reportMetadata)
+  // and the SDK status stream (via notifyPermissionModeChanged → registered
+  // in print.ts). The scattered callsites above need zero changes.
+  const prevMode = oldState.toolPermissionContext.mode
+  const newMode = newState.toolPermissionContext.mode
+  if (prevMode !== newMode) {
+    // CCR external_metadata must not receive internal-only mode names
+    // (bubble, ungated auto). Externalize first — and skip
+    // the CCR notify if the EXTERNAL mode didn't change (e.g.,
+    // default→bubble→default is noise from CCR's POV since both
+    // externalize to 'default'). The SDK channel (notifyPermissionModeChanged)
+    // passes raw mode; its listener in print.ts applies its own filter.
+    const prevExternal = toExternalPermissionMode(prevMode)
+    const newExternal = toExternalPermissionMode(newMode)
+    if (prevExternal !== newExternal) {
+      // Ultraplan = first plan cycle only. The initial control_request
+      // sets mode and isUltraplanMode atomically, so the flag's
+      // transition gates it. null per RFC 7396 (removes the key).
+      const isUltraplan =
+        newExternal === 'plan' &&
+        newState.isUltraplanMode &&
+        !oldState.isUltraplanMode
+          ? true
+          : null
+      notifySessionMetadataChanged({
+        permission_mode: newExternal,
+        is_ultraplan_mode: isUltraplan,
+      })
+    }
+    notifyPermissionModeChanged(newMode)
+  }
+
+  // mainLoopModel: remove it from settings?
+  if (
+    newState.mainLoopModel !== oldState.mainLoopModel &&
+    newState.mainLoopModel === null
+  ) {
+    // Remove from settings
+    updateSettingsForSource('userSettings', { model: undefined })
+    setMainLoopModelOverride(null)
+  }
+
+  // mainLoopModel: add it to settings?
+  if (
+    newState.mainLoopModel !== oldState.mainLoopModel &&
+    newState.mainLoopModel !== null
+  ) {
+    // Save to settings
+    updateSettingsForSource('userSettings', { model: newState.mainLoopModel })
+    setMainLoopModelOverride(newState.mainLoopModel)
+  }
+
+  // expandedView → persist as showExpandedTodos + showSpinnerTree for backwards compat
+  if (newState.expandedView !== oldState.expandedView) {
+    const showExpandedTodos = newState.expandedView === 'tasks'
+    const showSpinnerTree = newState.expandedView === 'teammates'
+    if (
+      getGlobalConfig().showExpandedTodos !== showExpandedTodos ||
+      getGlobalConfig().showSpinnerTree !== showSpinnerTree
+    ) {
+      saveGlobalConfig(current => ({
+        ...current,
+        showExpandedTodos,
+        showSpinnerTree,
+      }))
+    }
+  }
+
+  // verbose
+  if (
+    newState.verbose !== oldState.verbose &&
+    getGlobalConfig().verbose !== newState.verbose
+  ) {
+    const verbose = newState.verbose
+    saveGlobalConfig(current => ({
+      ...current,
+      verbose,
+    }))
+  }
+
+  // tungstenPanelVisible (ant-only tmux panel sticky toggle)
+  if (process.env.USER_TYPE === 'ant') {
+    if (
+      newState.tungstenPanelVisible !== oldState.tungstenPanelVisible &&
+      newState.tungstenPanelVisible !== undefined &&
+      getGlobalConfig().tungstenPanelVisible !== newState.tungstenPanelVisible
+    ) {
+      const tungstenPanelVisible = newState.tungstenPanelVisible
+      saveGlobalConfig(current => ({ ...current, tungstenPanelVisible }))
+    }
+  }
+
+  // settings: clear auth-related caches when settings change
+  // This ensures apiKeyHelper and AWS/GCP credential changes take effect immediately
+  if (newState.settings !== oldState.settings) {
+    try {
+      clearApiKeyHelperCache()
+      clearAwsCredentialsCache()
+      clearGcpCredentialsCache()
+
+      // Re-apply environment variables when settings.env changes
+      // This is additive-only: new vars are added, existing may be overwritten, nothing is deleted
+      if (newState.settings.env !== oldState.settings.env) {
+        applyConfigEnvironmentVariables()
+      }
+    } catch (error) {
+      logError(toError(error))
+    }
+  }
+}

package/state/selectors.ts

@@ -0,0 +1,76 @@
+/**
+ * Selectors for deriving computed state from AppState.
+ * Keep selectors pure and simple - just data extraction, no side effects.
+ */
+
+import type { InProcessTeammateTaskState } from '../tasks/InProcessTeammateTask/types.js'
+import { isInProcessTeammateTask } from '../tasks/InProcessTeammateTask/types.js'
+import type { LocalAgentTaskState } from '../tasks/LocalAgentTask/LocalAgentTask.js'
+import type { AppState } from './AppStateStore.js'
+
+/**
+ * Get the currently viewed teammate task, if any.
+ * Returns undefined if:
+ * - No teammate is being viewed (viewingAgentTaskId is undefined)
+ * - The task ID doesn't exist in tasks
+ * - The task is not an in-process teammate task
+ */
+export function getViewedTeammateTask(
+  appState: Pick<AppState, 'viewingAgentTaskId' | 'tasks'>,
+): InProcessTeammateTaskState | undefined {
+  const { viewingAgentTaskId, tasks } = appState
+
+  // Not viewing any teammate
+  if (!viewingAgentTaskId) {
+    return undefined
+  }
+
+  // Look up the task
+  const task = tasks[viewingAgentTaskId]
+  if (!task) {
+    return undefined
+  }
+
+  // Verify it's an in-process teammate task
+  if (!isInProcessTeammateTask(task)) {
+    return undefined
+  }
+
+  return task
+}
+
+/**
+ * Return type for getActiveAgentForInput selector.
+ * Discriminated union for type-safe input routing.
+ */
+export type ActiveAgentForInput =
+  | { type: 'leader' }
+  | { type: 'viewed'; task: InProcessTeammateTaskState }
+  | { type: 'named_agent'; task: LocalAgentTaskState }
+
+/**
+ * Determine where user input should be routed.
+ * Returns:
+ * - { type: 'leader' } when not viewing a teammate (input goes to leader)
+ * - { type: 'viewed', task } when viewing an agent (input goes to that agent)
+ *
+ * Used by input routing logic to direct user messages to the correct agent.
+ */
+export function getActiveAgentForInput(
+  appState: AppState,
+): ActiveAgentForInput {
+  const viewedTask = getViewedTeammateTask(appState)
+  if (viewedTask) {
+    return { type: 'viewed', task: viewedTask }
+  }
+
+  const { viewingAgentTaskId, tasks } = appState
+  if (viewingAgentTaskId) {
+    const task = tasks[viewingAgentTaskId]
+    if (task?.type === 'local_agent') {
+      return { type: 'named_agent', task }
+    }
+  }
+
+  return { type: 'leader' }
+}

package/state/store.ts

@@ -0,0 +1,34 @@
+type Listener = () => void
+type OnChange<T> = (args: { newState: T; oldState: T }) => void
+
+export type Store<T> = {
+  getState: () => T
+  setState: (updater: (prev: T) => T) => void
+  subscribe: (listener: Listener) => () => void
+}
+
+export function createStore<T>(
+  initialState: T,
+  onChange?: OnChange<T>,
+): Store<T> {
+  let state = initialState
+  const listeners = new Set<Listener>()
+
+  return {
+    getState: () => state,
+
+    setState: (updater: (prev: T) => T) => {
+      const prev = state
+      const next = updater(prev)
+      if (Object.is(next, prev)) return
+      state = next
+      onChange?.({ newState: next, oldState: prev })
+      for (const listener of listeners) listener()
+    },
+
+    subscribe: (listener: Listener) => {
+      listeners.add(listener)
+      return () => listeners.delete(listener)
+    },
+  }
+}

package/state/teammateViewHelpers.ts

@@ -0,0 +1,141 @@
+import { logEvent } from '../services/analytics/index.js'
+import { isTerminalTaskStatus } from '../Task.js'
+import type { LocalAgentTaskState } from '../tasks/LocalAgentTask/LocalAgentTask.js'
+
+// Inlined from framework.ts — importing creates a cycle through
+// BackgroundTasksDialog. Keep in sync with PANEL_GRACE_MS there.
+const PANEL_GRACE_MS = 30_000
+
+import type { AppState } from './AppState.js'
+
+// Inline type check instead of importing isLocalAgentTask — breaks the
+// teammateViewHelpers → LocalAgentTask runtime edge that creates a cycle
+// through BackgroundTasksDialog.
+function isLocalAgent(task: unknown): task is LocalAgentTaskState {
+  return (
+    typeof task === 'object' &&
+    task !== null &&
+    'type' in task &&
+    task.type === 'local_agent'
+  )
+}
+
+/**
+ * Return the task released back to stub form: retain dropped, messages
+ * cleared, evictAfter set if terminal. Shared by exitTeammateView and
+ * the switch-away path in enterTeammateView.
+ */
+function release(task: LocalAgentTaskState): LocalAgentTaskState {
+  return {
+    ...task,
+    retain: false,
+    messages: undefined,
+    diskLoaded: false,
+    evictAfter: isTerminalTaskStatus(task.status)
+      ? Date.now() + PANEL_GRACE_MS
+      : undefined,
+  }
+}
+
+/**
+ * Transitions the UI to view a teammate's transcript.
+ * Sets viewingAgentTaskId and, for local_agent, retain: true (blocks eviction,
+ * enables stream-append, triggers disk bootstrap) and clears evictAfter.
+ * If switching from another agent, releases the previous one back to stub.
+ */
+export function enterTeammateView(
+  taskId: string,
+  setAppState: (updater: (prev: AppState) => AppState) => void,
+): void {
+  logEvent('tengu_transcript_view_enter', {})
+  setAppState(prev => {
+    const task = prev.tasks[taskId]
+    const prevId = prev.viewingAgentTaskId
+    const prevTask = prevId !== undefined ? prev.tasks[prevId] : undefined
+    const switching =
+      prevId !== undefined &&
+      prevId !== taskId &&
+      isLocalAgent(prevTask) &&
+      prevTask.retain
+    const needsRetain =
+      isLocalAgent(task) && (!task.retain || task.evictAfter !== undefined)
+    const needsView =
+      prev.viewingAgentTaskId !== taskId ||
+      prev.viewSelectionMode !== 'viewing-agent'
+    if (!needsRetain && !needsView && !switching) return prev
+    let tasks = prev.tasks
+    if (switching || needsRetain) {
+      tasks = { ...prev.tasks }
+      if (switching) tasks[prevId] = release(prevTask)
+      if (needsRetain) {
+        tasks[taskId] = { ...task, retain: true, evictAfter: undefined }
+      }
+    }
+    return {
+      ...prev,
+      viewingAgentTaskId: taskId,
+      viewSelectionMode: 'viewing-agent',
+      tasks,
+    }
+  })
+}
+
+/**
+ * Exit teammate transcript view and return to leader's view.
+ * Drops retain and clears messages back to stub form; if terminal,
+ * schedules eviction via evictAfter so the row lingers briefly.
+ */
+export function exitTeammateView(
+  setAppState: (updater: (prev: AppState) => AppState) => void,
+): void {
+  logEvent('tengu_transcript_view_exit', {})
+  setAppState(prev => {
+    const id = prev.viewingAgentTaskId
+    const cleared = {
+      ...prev,
+      viewingAgentTaskId: undefined,
+      viewSelectionMode: 'none' as const,
+    }
+    if (id === undefined) {
+      return prev.viewSelectionMode === 'none' ? prev : cleared
+    }
+    const task = prev.tasks[id]
+    if (!isLocalAgent(task) || !task.retain) return cleared
+    return {
+      ...cleared,
+      tasks: { ...prev.tasks, [id]: release(task) },
+    }
+  })
+}
+
+/**
+ * Context-sensitive x: running → abort, terminal → dismiss.
+ * Dismiss sets evictAfter=0 so the filter hides immediately.
+ * If viewing the dismissed agent, also exits to leader.
+ */
+export function stopOrDismissAgent(
+  taskId: string,
+  setAppState: (updater: (prev: AppState) => AppState) => void,
+): void {
+  setAppState(prev => {
+    const task = prev.tasks[taskId]
+    if (!isLocalAgent(task)) return prev
+    if (task.status === 'running') {
+      task.abortController?.abort()
+      return prev
+    }
+    if (task.evictAfter === 0) return prev
+    const viewingThis = prev.viewingAgentTaskId === taskId
+    return {
+      ...prev,
+      tasks: {
+        ...prev.tasks,
+        [taskId]: { ...release(task), evictAfter: 0 },
+      },
+      ...(viewingThis && {
+        viewingAgentTaskId: undefined,
+        viewSelectionMode: 'none',
+      }),
+    }
+  })
+}

package/tasks/DreamTask/DreamTask.ts

@@ -0,0 +1,157 @@
+// Background task entry for auto-dream (memory consolidation subagent).
+// Makes the otherwise-invisible forked agent visible in the footer pill and
+// Shift+Down dialog. The dream agent itself is unchanged — this is pure UI
+// surfacing via the existing task registry.
+
+import { rollbackConsolidationLock } from '../../services/autoDream/consolidationLock.js'
+import type { SetAppState, Task, TaskStateBase } from '../../Task.js'
+import { createTaskStateBase, generateTaskId } from '../../Task.js'
+import { registerTask, updateTaskState } from '../../utils/task/framework.js'
+
+// Keep only the N most recent turns for live display.
+const MAX_TURNS = 30
+
+// A single assistant turn from the dream agent, tool uses collapsed to a count.
+export type DreamTurn = {
+  text: string
+  toolUseCount: number
+}
+
+// No phase detection — the dream prompt has a 4-stage structure
+// (orient/gather/consolidate/prune) but we don't parse it. Just flip from
+// 'starting' to 'updating' when the first Edit/Write tool_use lands.
+export type DreamPhase = 'starting' | 'updating'
+
+export type DreamTaskState = TaskStateBase & {
+  type: 'dream'
+  phase: DreamPhase
+  sessionsReviewing: number
+  /**
+   * Paths observed in Edit/Write tool_use blocks via onMessage. This is an
+   * INCOMPLETE reflection of what the dream agent actually changed — it misses
+   * any bash-mediated writes and only captures the tool calls we pattern-match.
+   * Treat as "at least these were touched", not "only these were touched".
+   */
+  filesTouched: string[]
+  /** Assistant text responses, tool uses collapsed. Prompt is NOT included. */
+  turns: DreamTurn[]
+  abortController?: AbortController
+  /** Stashed so kill can rewind the lock mtime (same path as fork-failure). */
+  priorMtime: number
+}
+
+export function isDreamTask(task: unknown): task is DreamTaskState {
+  return (
+    typeof task === 'object' &&
+    task !== null &&
+    'type' in task &&
+    task.type === 'dream'
+  )
+}
+
+export function registerDreamTask(
+  setAppState: SetAppState,
+  opts: {
+    sessionsReviewing: number
+    priorMtime: number
+    abortController: AbortController
+  },
+): string {
+  const id = generateTaskId('dream')
+  const task: DreamTaskState = {
+    ...createTaskStateBase(id, 'dream', 'dreaming'),
+    type: 'dream',
+    status: 'running',
+    phase: 'starting',
+    sessionsReviewing: opts.sessionsReviewing,
+    filesTouched: [],
+    turns: [],
+    abortController: opts.abortController,
+    priorMtime: opts.priorMtime,
+  }
+  registerTask(task, setAppState)
+  return id
+}
+
+export function addDreamTurn(
+  taskId: string,
+  turn: DreamTurn,
+  touchedPaths: string[],
+  setAppState: SetAppState,
+): void {
+  updateTaskState<DreamTaskState>(taskId, setAppState, task => {
+    const seen = new Set(task.filesTouched)
+    const newTouched = touchedPaths.filter(p => !seen.has(p) && seen.add(p))
+    // Skip the update entirely if the turn is empty AND nothing new was
+    // touched. Avoids re-rendering on pure no-ops.
+    if (
+      turn.text === '' &&
+      turn.toolUseCount === 0 &&
+      newTouched.length === 0
+    ) {
+      return task
+    }
+    return {
+      ...task,
+      phase: newTouched.length > 0 ? 'updating' : task.phase,
+      filesTouched:
+        newTouched.length > 0
+          ? [...task.filesTouched, ...newTouched]
+          : task.filesTouched,
+      turns: task.turns.slice(-(MAX_TURNS - 1)).concat(turn),
+    }
+  })
+}
+
+export function completeDreamTask(
+  taskId: string,
+  setAppState: SetAppState,
+): void {
+  // notified: true immediately — dream has no model-facing notification path
+  // (it's UI-only), and eviction requires terminal + notified. The inline
+  // appendSystemMessage completion note IS the user surface.
+  updateTaskState<DreamTaskState>(taskId, setAppState, task => ({
+    ...task,
+    status: 'completed',
+    endTime: Date.now(),
+    notified: true,
+    abortController: undefined,
+  }))
+}
+
+export function failDreamTask(taskId: string, setAppState: SetAppState): void {
+  updateTaskState<DreamTaskState>(taskId, setAppState, task => ({
+    ...task,
+    status: 'failed',
+    endTime: Date.now(),
+    notified: true,
+    abortController: undefined,
+  }))
+}
+
+export const DreamTask: Task = {
+  name: 'DreamTask',
+  type: 'dream',
+
+  async kill(taskId, setAppState) {
+    let priorMtime: number | undefined
+    updateTaskState<DreamTaskState>(taskId, setAppState, task => {
+      if (task.status !== 'running') return task
+      task.abortController?.abort()
+      priorMtime = task.priorMtime
+      return {
+        ...task,
+        status: 'killed',
+        endTime: Date.now(),
+        notified: true,
+        abortController: undefined,
+      }
+    })
+    // Rewind the lock mtime so the next session can retry. Same path as the
+    // fork-failure catch in autoDream.ts. If updateTaskState was a no-op
+    // (already terminal), priorMtime stays undefined and we skip.
+    if (priorMtime !== undefined) {
+      await rollbackConsolidationLock(priorMtime)
+    }
+  },
+}