@adhdev/daemon-core 0.9.81 → 0.9.82-rc.10

package/src/commands/router.ts

@@ -26,6 +26,8 @@ import { getSavedProviderSessions } from '../config/saved-sessions.js';
 import { listProviderHistorySessions } from '../config/chat-history.js';
 import { detectIDEs } from '../detection/ide-detector.js';
 import { detectCLI } from '../detection/cli-detector.js';
+import { getGitRepoStatus } from '../git/git-status.js';
+import type { GitSubmoduleStatus } from '../git/git-types.js';
 import { SessionRegistry } from '../sessions/registry.js';
 import { LOG } from '../logging/logger.js';
 import { logCommand } from '../logging/command-log.js';
@@ -85,6 +87,276 @@ function readProviderPriorityFromPolicy(policy: unknown): string[] {
         });
 }
 
+function readObjectRecord(value: unknown): Record<string, any> {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value as Record<string, any>
+        : {};
+}
+
+function readStringValue(...values: unknown[]): string | undefined {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim()) return value.trim();
+    }
+    return undefined;
+}
+
+function readNumberValue(...values: unknown[]): number | undefined {
+    for (const value of values) {
+        if (typeof value === 'number' && Number.isFinite(value)) return value;
+    }
+    return undefined;
+}
+
+function readBooleanValue(...values: unknown[]): boolean | undefined {
+    for (const value of values) {
+        if (typeof value === 'boolean') return value;
+    }
+    return undefined;
+}
+
+function readGitSubmodules(value: unknown): GitSubmoduleStatus[] | undefined {
+    if (!Array.isArray(value)) return undefined;
+    const submodules = value
+        .map(entry => {
+            const submodule = readObjectRecord(entry);
+            const path = readStringValue(submodule.path);
+            const commit = readStringValue(submodule.commit);
+            const repoPath = readStringValue(submodule.repoPath, submodule.repo_root);
+            if (!path || !commit || !repoPath) return null;
+            return {
+                path,
+                commit,
+                repoPath,
+                dirty: readBooleanValue(submodule.dirty) ?? false,
+                outOfSync: readBooleanValue(submodule.outOfSync, submodule.out_of_sync) ?? false,
+                lastCheckedAt: readNumberValue(submodule.lastCheckedAt, submodule.last_checked_at) ?? Date.now(),
+                ...(readStringValue(submodule.error) ? { error: readStringValue(submodule.error) } : {}),
+            };
+        })
+        .filter((entry): entry is GitSubmoduleStatus => entry !== null);
+    return submodules.length > 0 ? submodules : undefined;
+}
+
+function buildCachedInlineMeshGitStatus(node: any): Record<string, unknown> | undefined {
+    const cachedStatus = readObjectRecord(node?.cachedStatus);
+    const cachedGit = readObjectRecord(cachedStatus.git);
+    if (Object.keys(cachedGit).length) {
+        const conflictFiles = Array.isArray(cachedGit.conflictFiles)
+            ? cachedGit.conflictFiles.filter((value: unknown): value is string => typeof value === 'string')
+            : [];
+        const conflictCount = readNumberValue(cachedGit.conflicts) ?? conflictFiles.length;
+        const hasConflicts = readBooleanValue(cachedGit.hasConflicts) ?? conflictCount > 0;
+        const isGitRepo = readBooleanValue(cachedGit.isGitRepo);
+        if (isGitRepo !== undefined) {
+            const submodules = readGitSubmodules(cachedGit.submodules);
+            return {
+                workspace: readStringValue(cachedGit.workspace, node?.workspace) || '',
+                repoRoot: readStringValue(cachedGit.repoRoot, node?.repoRoot, node?.workspace) || null,
+                isGitRepo,
+                branch: readStringValue(cachedGit.branch) ?? null,
+                headCommit: readStringValue(cachedGit.headCommit) ?? null,
+                headMessage: readStringValue(cachedGit.headMessage) ?? null,
+                upstream: readStringValue(cachedGit.upstream) ?? null,
+                ahead: readNumberValue(cachedGit.ahead) ?? 0,
+                behind: readNumberValue(cachedGit.behind) ?? 0,
+                staged: readNumberValue(cachedGit.staged) ?? 0,
+                modified: readNumberValue(cachedGit.modified) ?? 0,
+                untracked: readNumberValue(cachedGit.untracked) ?? 0,
+                deleted: readNumberValue(cachedGit.deleted) ?? 0,
+                renamed: readNumberValue(cachedGit.renamed) ?? 0,
+                hasConflicts,
+                conflictFiles,
+                stashCount: readNumberValue(cachedGit.stashCount) ?? 0,
+                lastCheckedAt: readNumberValue(cachedGit.lastCheckedAt) ?? Date.now(),
+                ...(submodules ? { submodules } : {}),
+            };
+        }
+    }
+
+    const rawGit = readObjectRecord(node?.lastGit ?? node?.last_git);
+    const gitResult = readObjectRecord(rawGit.result);
+    const directStatus = readObjectRecord(rawGit.status);
+    const nestedStatus = readObjectRecord(gitResult.status);
+    const rawProbe = readObjectRecord(node?.lastProbe ?? node?.last_probe);
+    const probeGit = readObjectRecord(rawProbe.git);
+    const probeGitResult = readObjectRecord(probeGit.result);
+    const probeDirectStatus = readObjectRecord(probeGit.status);
+    const probeNestedStatus = readObjectRecord(probeGitResult.status);
+    const status = Object.keys(directStatus).length
+        ? directStatus
+        : Object.keys(nestedStatus).length
+            ? nestedStatus
+            : Object.keys(probeDirectStatus).length
+                ? probeDirectStatus
+                : Object.keys(probeNestedStatus).length
+                    ? probeNestedStatus
+                    : {};
+    const isGitRepo = readBooleanValue(status.isGitRepo);
+    if (!Object.keys(status).length || isGitRepo === undefined) return undefined;
+    const conflictFiles = Array.isArray(status.conflictFiles)
+        ? status.conflictFiles.filter((value: unknown): value is string => typeof value === 'string')
+        : [];
+    const conflictCount = readNumberValue(status.conflicts) ?? conflictFiles.length;
+    const hasConflicts = readBooleanValue(status.hasConflicts) ?? conflictCount > 0;
+    const submodules = readGitSubmodules(status.submodules);
+    return {
+        workspace: readStringValue(status.workspace, node?.workspace) || '',
+        repoRoot: readStringValue(status.repoRoot, node?.repoRoot, node?.workspace) || null,
+        isGitRepo,
+        branch: readStringValue(status.branch) ?? null,
+        headCommit: readStringValue(status.headCommit) ?? null,
+        headMessage: readStringValue(status.headMessage) ?? null,
+        upstream: readStringValue(status.upstream) ?? null,
+        ahead: readNumberValue(status.ahead) ?? 0,
+        behind: readNumberValue(status.behind) ?? 0,
+        staged: readNumberValue(status.staged) ?? 0,
+        modified: readNumberValue(status.modified) ?? 0,
+        untracked: readNumberValue(status.untracked) ?? 0,
+        deleted: readNumberValue(status.deleted) ?? 0,
+        renamed: readNumberValue(status.renamed) ?? 0,
+        hasConflicts,
+        conflictFiles,
+        stashCount: readNumberValue(status.stashCount) ?? 0,
+        lastCheckedAt: Date.now(),
+        ...(submodules ? { submodules } : {}),
+    };
+}
+
+function hasGitWorktreeChanges(git: Record<string, unknown> | null | undefined): boolean {
+    if (!git) return false;
+    return Number(git.staged || 0) + Number(git.modified || 0) + Number(git.untracked || 0) + Number(git.deleted || 0) + Number(git.renamed || 0) > 0;
+}
+
+function getGitSubmoduleDriftState(git: Record<string, unknown> | null | undefined): { dirty: boolean; outOfSync: boolean } {
+    const submodules = Array.isArray(git?.submodules) ? git.submodules : [];
+    let dirty = false;
+    let outOfSync = false;
+    for (const entry of submodules) {
+        const submodule = readObjectRecord(entry);
+        if (readBooleanValue(submodule.dirty) === true) dirty = true;
+        if (readBooleanValue(submodule.outOfSync) === true || !!readStringValue(submodule.error)) outOfSync = true;
+    }
+    return { dirty, outOfSync };
+}
+
+function deriveMeshNodeHealthFromGit(git: Record<string, unknown> | null | undefined): 'online' | 'dirty' | 'degraded' {
+    if (!git || readBooleanValue(git.isGitRepo) === false) return 'degraded';
+    const branch = readStringValue(git.branch);
+    if (!branch) return 'degraded';
+    const submoduleDrift = getGitSubmoduleDriftState(git);
+    if (submoduleDrift.outOfSync) return 'degraded';
+    if (submoduleDrift.dirty || hasGitWorktreeChanges(git)) return 'dirty';
+    return 'online';
+}
+
+function readCachedInlineMeshActiveSessions(node: any): string[] {
+    const cachedStatus = readObjectRecord(node?.cachedStatus);
+    const activeSession = readObjectRecord(cachedStatus.activeSession);
+    const fallbackSession = Object.keys(activeSession).length
+        ? activeSession
+        : readObjectRecord(node?.activeSession ?? node?.active_session);
+    const sessionId = readStringValue(fallbackSession.id, fallbackSession.sessionId, fallbackSession.session_id, node?.activeSessionId, node?.active_session_id, node?.sessionId, node?.session_id);
+    return sessionId ? [sessionId] : [];
+}
+
+function readCachedInlineMeshActiveSessionDetails(node: any): Array<Record<string, unknown>> {
+    const cachedStatus = readObjectRecord(node?.cachedStatus);
+    const activeSession = readObjectRecord(cachedStatus.activeSession);
+    const fallbackSession = Object.keys(activeSession).length
+        ? activeSession
+        : readObjectRecord(node?.activeSession ?? node?.active_session);
+    const sessionId = readStringValue(
+        fallbackSession.id,
+        fallbackSession.sessionId,
+        fallbackSession.session_id,
+        node?.activeSessionId,
+        node?.active_session_id,
+        node?.sessionId,
+        node?.session_id,
+    );
+    if (!sessionId) return [];
+    return [{
+        sessionId,
+        providerType: readStringValue(
+            fallbackSession.providerType,
+            fallbackSession.provider_type,
+            fallbackSession.cliType,
+            fallbackSession.cli_type,
+            fallbackSession.provider,
+            node?.providerType,
+            node?.provider_type,
+        ),
+        state: readStringValue(fallbackSession.status, fallbackSession.state, fallbackSession.lifecycle),
+        lifecycle: readStringValue(fallbackSession.lifecycle),
+        title: readStringValue(fallbackSession.title, fallbackSession.displayName, fallbackSession.display_name) ?? null,
+        workspace: readStringValue(fallbackSession.workspace, node?.workspace) ?? null,
+        lastActivityAt: readStringValue(fallbackSession.lastActivityAt, fallbackSession.last_activity_at) ?? null,
+        recoveryState: readStringValue(fallbackSession.recoveryState, fallbackSession.recovery_state) ?? null,
+        isCached: true,
+    }];
+}
+
+function readLiveMeshSessionState(record: any): string | undefined {
+    return readStringValue(
+        record?.meta?.sessionStatus,
+        record?.meta?.status,
+        record?.meta?.providerStatus,
+        record?.status,
+        record?.state,
+        record?.lifecycle,
+    );
+}
+
+function toIsoTimestamp(value: unknown): string | null {
+    if (typeof value === 'number' && Number.isFinite(value)) return new Date(value).toISOString();
+    const stringValue = readStringValue(value);
+    return stringValue || null;
+}
+
+function summarizeMeshSessionRecord(record: any): Record<string, unknown> {
+    return {
+        sessionId: readStringValue(record?.sessionId) || 'unknown',
+        providerType: readStringValue(record?.providerType),
+        state: readLiveMeshSessionState(record),
+        lifecycle: readStringValue(record?.lifecycle),
+        surfaceKind: getSessionHostSurfaceKind(record as any),
+        recoveryState: readStringValue(record?.meta?.runtimeRecoveryState) ?? null,
+        workspace: readStringValue(record?.workspace) ?? null,
+        title: readStringValue(record?.displayName, record?.workspaceLabel) ?? null,
+        lastActivityAt: toIsoTimestamp(record?.updatedAt ?? record?.lastActivityAt ?? record?.last_activity_at),
+        isCached: false,
+    };
+}
+
+function applyCachedInlineMeshNodeStatus(status: Record<string, unknown>, node: any): boolean {
+    const cachedStatus = readObjectRecord(node?.cachedStatus);
+    const git = buildCachedInlineMeshGitStatus(node);
+    const error = readStringValue(cachedStatus.error, node?.error);
+    const health = readStringValue(cachedStatus.health, node?.health);
+    const machineStatus = readStringValue(cachedStatus.machineStatus, node?.machineStatus);
+    const lastSeenAt = toIsoTimestamp(cachedStatus.lastSeenAt ?? cachedStatus.last_seen_at ?? node?.lastSeenAt ?? node?.last_seen_at);
+    const updatedAt = toIsoTimestamp(cachedStatus.updatedAt ?? cachedStatus.updated_at ?? node?.updatedAt ?? node?.updated_at);
+    const activeSessions = readCachedInlineMeshActiveSessions(node);
+    const activeSessionDetails = readCachedInlineMeshActiveSessionDetails(node);
+    if (!git && !error && !health && !machineStatus && !lastSeenAt && !updatedAt && activeSessions.length === 0) return false;
+    if (git) status.git = git;
+    if (error) status.error = error;
+    if (machineStatus) status.machineStatus = machineStatus;
+    if (lastSeenAt) status.lastSeenAt = lastSeenAt;
+    if (updatedAt) status.updatedAt = updatedAt;
+    if (activeSessions.length > 0) status.activeSessions = activeSessions;
+    if (activeSessionDetails.length > 0) status.activeSessionDetails = activeSessionDetails;
+    if (health) {
+        status.health = health;
+        return true;
+    }
+    if (git) {
+        status.health = deriveMeshNodeHealthFromGit(git);
+        return true;
+    }
+    return activeSessions.length > 0 || !!machineStatus || !!lastSeenAt || !!updatedAt;
+}
+
 async function resolveProviderTypeFromPriority(args: {
     nodeId: string;
     providerPriority: string[];
@@ -502,6 +774,8 @@ export interface CommandRouterDeps {
     statusVersion?: string;
     /** Session host control plane */
     sessionHostControl?: SessionHostControlPlane | null;
+    /** Selected-coordinator mesh peer telemetry surface for target daemons, when supported by the runtime. */
+    getMeshPeerConnectionStatus?: (daemonId: string) => Record<string, unknown> | null;
 }
 
 export interface CommandRouterResult {
@@ -632,7 +906,16 @@ export class DaemonCommandRouter {
         return this.inlineMeshCache.get(meshId);
     }
 
-    private async getMeshForCommand(meshId: string, inlineMesh?: unknown): Promise<{ mesh: any; inline: boolean } | null> {
+    private async getMeshForCommand(
+        meshId: string,
+        inlineMesh?: unknown,
+        options?: { preferInline?: boolean },
+    ): Promise<{ mesh: any; inline: boolean } | null> {
+        const preferInline = options?.preferInline === true;
+        if (preferInline) {
+            const cached = this.getCachedInlineMesh(meshId, inlineMesh);
+            if (cached) return { mesh: cached, inline: true };
+        }
         try {
             const { getMesh } = await import('../config/mesh-config.js');
             const mesh = getMesh(meshId);
@@ -2734,7 +3017,7 @@ export class DaemonCommandRouter {
                 const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
                 if (!meshId) return { success: false, error: 'meshId required' };
                 try {
-                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
                     const mesh = meshRecord?.mesh;
                     if (!mesh) return { success: false, error: 'Mesh not found' };
 
@@ -2745,90 +3028,112 @@ export class DaemonCommandRouter {
                     const { readLedgerEntries, getLedgerSummary } = await import('../mesh/mesh-ledger.js');
                     const ledgerEntries = readLedgerEntries(meshId, { tail: 20 });
                     const ledgerSummary = getLedgerSummary(meshId);
+                    const sessionHostRecords = this.deps.sessionHostControl?.listSessions
+                        ? await this.deps.sessionHostControl.listSessions().catch(() => [])
+                        : [];
+                    const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
 
+                    const localMachineId = loadConfig().machineId || '';
+                    const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes)
+                        ? readStringValue((mesh.nodes[0] as any)?.id, (mesh.nodes[0] as any)?.nodeId)
+                        : undefined;
+                    const refreshedAt = new Date().toISOString();
                     const nodeStatuses = [];
-                    for (const node of mesh.nodes || []) {
+                    for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
+                        const nodeId = String(node.id || node.nodeId || '');
+                        const daemonId = readStringValue(node.daemonId);
+                        const providerPriority = readProviderPriorityFromPolicy(node.policy);
+                        const isSelfNode = Boolean(
+                            nodeId && inlineCoordinatorNodeId && nodeId === inlineCoordinatorNodeId,
+                        ) || Boolean(
+                            daemonId && (daemonId === localMachineId || daemonId === this.deps.statusInstanceId),
+                        ) || Boolean(meshRecord?.inline && nodeIndex === 0);
                         const status: Record<string, unknown> = {
-                            nodeId: node.id || node.nodeId,
+                            nodeId,
                             machineLabel: node.machineLabel || node.id || node.nodeId,
                             workspace: node.workspace,
                             repoRoot: node.repoRoot,
                             isLocalWorktree: node.isLocalWorktree,
                             worktreeBranch: node.worktreeBranch,
-                            daemonId: node.daemonId,
+                            daemonId,
                             machineId: node.machineId,
+                            machineStatus: node.machineStatus,
                             health: 'unknown',
                             providers: node.providers || [],
+                            providerPriority,
                             activeSessions: [],
+                            activeSessionDetails: [],
+                            launchReady: false,
                         };
+                        if (isSelfNode) {
+                            status.connection = {
+                                perspective: 'selected_coordinator',
+                                source: 'mesh_peer_status',
+                                state: 'self',
+                                transport: 'local',
+                                reported: true,
+                                reason: 'Selected coordinator daemon',
+                                lastStateChangeAt: refreshedAt,
+                            };
+                        } else if (daemonId) {
+                            const connection = this.deps.getMeshPeerConnectionStatus?.(daemonId);
+                            status.connection = connection ?? {
+                                perspective: 'selected_coordinator',
+                                source: 'not_reported',
+                                state: 'unknown',
+                                transport: 'unknown',
+                                reported: false,
+                                reason: 'No live mesh peer telemetry reported by the selected coordinator yet.',
+                            };
+                        } else {
+                            status.connection = {
+                                perspective: 'selected_coordinator',
+                                source: 'not_reported',
+                                state: 'unknown',
+                                transport: 'unknown',
+                                reported: false,
+                                reason: 'Node has no daemon id, so mesh transport cannot be reported from the selected coordinator.',
+                            };
+                        }
+                        const matchedLiveSessionRecords = liveMeshSessions
+                            .filter((record) => this.sessionMatchesMeshNode(record, node, nodeId));
+                        if (matchedLiveSessionRecords.length > 0) {
+                            const sessionIds = matchedLiveSessionRecords
+                                .map((record: any) => typeof record?.sessionId === 'string' ? record.sessionId : '')
+                                .filter(Boolean);
+                            const providerTypes = matchedLiveSessionRecords
+                                .map((record: any) => readStringValue(record?.providerType))
+                                .filter(Boolean) as string[];
+                            status.activeSessions = sessionIds;
+                            status.activeSessionDetails = matchedLiveSessionRecords.map(summarizeMeshSessionRecord);
+                            if (providerTypes.length > 0) {
+                                status.providers = Array.from(new Set([...(Array.isArray(status.providers) ? status.providers as string[] : []), ...providerTypes]));
+                            }
+                        }
                         if (node.workspace && typeof node.workspace === 'string') {
+                            if (!fs.existsSync(node.workspace as string) && applyCachedInlineMeshNodeStatus(status, node)) {
+                                status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === 'online' || isSelfNode);
+                                nodeStatuses.push(status);
+                                continue;
+                            }
                             try {
-                                const { execFile } = await import('node:child_process');
-                                const { promisify } = await import('node:util');
-                                const execFileAsync = promisify(execFile);
-
-                                const runGit = async (args: string[]): Promise<string> => {
-                                    const result = await execFileAsync('git', ['-C', node.workspace as string, ...args], {
-                                        encoding: 'utf8',
-                                        timeout: 10_000,
-                                    });
-                                    return result.stdout.trim();
-                                };
-
-                                const branch = await runGit(['branch', '--show-current']).catch(() => '');
-                                const porc = await runGit(['status', '--porcelain']).catch(() => '');
-                                const headCommit = await runGit(['rev-parse', '--short', 'HEAD']).catch(() => null);
-                                const headMessage = await runGit(['log', '-1', '--format=%s']).catch(() => null);
-                                const upstream = await runGit(['rev-parse', '--abbrev-ref', '@{upstream}']).catch(() => null);
-                                const aheadBehind = await runGit(['rev-list', '--left-right', '--count', '@{upstream}...HEAD']).catch(() => '');
-                                const stashCount = await runGit(['stash', 'list']).catch(() => '');
-
-                                let ahead = 0, behind = 0;
-                                if (aheadBehind) {
-                                    const parts = aheadBehind.split(/\s+/);
-                                    if (parts.length >= 2) {
-                                        behind = parseInt(parts[0], 10) || 0;
-                                        ahead = parseInt(parts[1], 10) || 0;
-                                    }
+                                const gitStatus = await getGitRepoStatus(node.workspace as string, { timeoutMs: 10_000, refreshUpstream: true });
+                                status.git = gitStatus;
+                                if (gitStatus.isGitRepo) {
+                                    status.health = deriveMeshNodeHealthFromGit(gitStatus as unknown as Record<string, unknown>);
+                                } else {
+                                    status.health = 'degraded';
+                                    if (gitStatus.error && !status.error) status.error = gitStatus.error;
                                 }
-
-                                const dirty = porc.length > 0;
-                                const lines = porc ? porc.split('\n').filter(Boolean) : [];
-                                let staged = 0, modified = 0, untracked = 0, deleted = 0, renamed = 0;
-                                for (const line of lines) {
-                                    const xy = line.slice(0, 2);
-                                    if (xy[0] !== ' ' && xy[0] !== '?') staged++;
-                                    if (xy[1] === 'M') modified++;
-                                    if (xy[1] === 'D') deleted++;
-                                    if (xy[0] === 'R' || xy[1] === 'R') renamed++;
-                                    if (xy === '??') untracked++;
-                                }
-
-                                status.git = {
-                                    workspace: node.workspace,
-                                    repoRoot: node.workspace,
-                                    isGitRepo: true,
-                                    branch: branch || null,
-                                    headCommit,
-                                    headMessage,
-                                    upstream,
-                                    ahead,
-                                    behind,
-                                    staged,
-                                    modified,
-                                    untracked,
-                                    deleted,
-                                    renamed,
-                                    hasConflicts: false,
-                                    conflictFiles: [],
-                                    stashCount: stashCount ? stashCount.split('\n').filter(Boolean).length : 0,
-                                    lastCheckedAt: Date.now(),
-                                };
-                                status.health = branch ? (dirty ? 'dirty' : 'online') : 'degraded';
                             } catch {
-                                status.health = 'degraded';
+                                if (!applyCachedInlineMeshNodeStatus(status, node)) {
+                                    status.health = 'degraded';
+                                }
                             }
+                        } else {
+                            applyCachedInlineMeshNodeStatus(status, node);
                         }
+                        status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === 'online' || isSelfNode);
                         nodeStatuses.push(status);
                     }
 
@@ -2838,6 +3143,7 @@ export class DaemonCommandRouter {
                         meshName: mesh.name,
                         repoIdentity: mesh.repoIdentity,
                         defaultBranch: mesh.defaultBranch,
+                        refreshedAt: new Date().toISOString(),
                         nodes: nodeStatuses,
                         queue: { tasks: queue, summary: queueSummary },
                         ledger: { entries: ledgerEntries, summary: ledgerSummary },

package/src/git/git-commands.ts

@@ -62,7 +62,7 @@ export interface GitPushResult extends GitRepoIdentity {
 }
 
 export interface GitCommandServices {
-  getStatus?: (params: { workspace: string }) => Promise<GitRepoStatus> | GitRepoStatus;
+  getStatus?: (params: { workspace: string; refreshUpstream?: boolean }) => Promise<GitRepoStatus> | GitRepoStatus;
   getDiffSummary?: (params: { workspace: string; staged?: boolean }) => Promise<GitDiffSummary> | GitDiffSummary;
   getDiffFile?: (params: { workspace: string; path: string; staged?: boolean }) => Promise<GitFileDiff> | GitFileDiff;
   createSnapshot?: (params: {
@@ -171,7 +171,7 @@ const defaultSnapshotStore = createGitSnapshotStore({
 
 export function createDefaultGitCommandServices(): GitCommandServices {
   return {
-    getStatus: ({ workspace }) => getGitRepoStatus(workspace),
+    getStatus: ({ workspace, refreshUpstream }) => getGitRepoStatus(workspace, { refreshUpstream }),
     getDiffSummary: ({ workspace }) => getGitDiffSummary(workspace),
     getDiffFile: ({ workspace, path: filePath }) => getGitFileDiff(workspace, filePath),
     createSnapshot: ({ workspace, reason, sessionId, turnId }) => defaultSnapshotStore.create({
@@ -290,7 +290,7 @@ export async function handleGitCommand(
   switch (command) {
     case 'git_status': {
       if (!services.getStatus) return serviceNotImplemented(command);
-      const status = await runService(() => services.getStatus!({ workspace }));
+      const status = await runService(() => services.getStatus!({ workspace, refreshUpstream: optionalBoolean(args?.refreshUpstream) }));
       return 'success' in status ? status : { success: true, status };
     }