@adhdev/daemon-core 0.9.76-rc.5 → 0.9.76-rc.50

package/src/providers/cli-provider-instance.ts

@@ -214,6 +214,7 @@ export class CliProviderInstance implements ProviderInstance {
         options?: {
             providerSessionId?: string;
             launchMode?: 'new' | 'resume' | 'manual';
+            extraEnv?: Record<string, string>;
             onProviderSessionResolved?: (info: {
                 instanceId: string;
                 providerType: string;
@@ -230,7 +231,7 @@ export class CliProviderInstance implements ProviderInstance {
         this.providerSessionId = options?.providerSessionId;
         this.launchMode = options?.launchMode || 'new';
         this.onProviderSessionResolved = options?.onProviderSessionResolved;
-        this.adapter = new ProviderCliAdapter(provider as CliProviderModule, workingDir, cliArgs, transportFactory);
+        this.adapter = new ProviderCliAdapter(provider as CliProviderModule, workingDir, cliArgs, options?.extraEnv || {}, transportFactory);
         this.monitor = new StatusMonitor();
         this.historyWriter = new ChatHistoryWriter();
     }
@@ -737,7 +738,29 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     private pushEvent(event: ProviderEvent): void {
-        this.events.push(event);
+        const enrichedEvent: ProviderEvent = {
+            ...event,
+            instanceId: typeof event.instanceId === 'string' && event.instanceId.trim()
+                ? event.instanceId
+                : this.instanceId,
+            targetSessionId: typeof event.targetSessionId === 'string' && event.targetSessionId.trim()
+                ? event.targetSessionId
+                : this.instanceId,
+            providerType: typeof event.providerType === 'string' && event.providerType.trim()
+                ? event.providerType
+                : this.type,
+            workspaceName: typeof event.workspaceName === 'string' && event.workspaceName.trim()
+                ? event.workspaceName
+                : this.workingDir,
+            providerSessionId: typeof event.providerSessionId === 'string' && event.providerSessionId.trim()
+                ? event.providerSessionId
+                : this.providerSessionId,
+        };
+        if (this.context?.emitProviderEvent) {
+            this.context.emitProviderEvent(enrichedEvent);
+            return;
+        }
+        this.events.push(enrichedEvent);
     }
 
     private flushEvents(): ProviderEvent[] {
@@ -977,15 +1000,40 @@ export class CliProviderInstance implements ProviderInstance {
         }
     }
 
+    mergeRuntimeChatMessages(parsedMessages: ChatMessage[]): ChatMessage[] {
+        return this.mergeConversationMessages(parsedMessages);
+    }
+
     private mergeConversationMessages(parsedMessages: any[]): ChatMessage[] {
         if (this.runtimeMessages.length === 0) return normalizeChatMessages(parsedMessages);
 
-        return normalizeChatMessages([...parsedMessages, ...this.runtimeMessages.map((entry) => entry.message)]
-            .map((message, index) => ({ message, index }))
+        type MergeEntry = { message: ChatMessage; index: number; source: 'parsed' | 'runtime' };
+        const parsedEntries: MergeEntry[] = parsedMessages.map((message, index) => ({
+            message,
+            index,
+            source: 'parsed',
+        }));
+        const runtimeEntries: MergeEntry[] = this.runtimeMessages.map((entry, index) => ({
+            message: entry.message,
+            index: parsedMessages.length + index,
+            source: 'runtime',
+        }));
+        const getTime = (message: ChatMessage): number => {
+            const value = typeof message.receivedAt === 'number'
+                ? message.receivedAt
+                : typeof message.timestamp === 'number'
+                    ? message.timestamp
+                    : 0;
+            return Number.isFinite(value) && value > 0 ? value : 0;
+        };
+
+        return normalizeChatMessages([...parsedEntries, ...runtimeEntries]
             .sort((a, b) => {
-                const aTime = a.message.receivedAt || a.message.timestamp || 0;
-                const bTime = b.message.receivedAt || b.message.timestamp || 0;
-                if (aTime !== bTime) return aTime - bTime;
+                const aTime = getTime(a.message);
+                const bTime = getTime(b.message);
+                if (aTime && bTime && aTime !== bTime) return aTime - bTime;
+                if (aTime && !bTime && a.source === 'runtime' && b.source === 'parsed') return -1;
+                if (!aTime && bTime && a.source === 'parsed' && b.source === 'runtime') return 1;
                 return a.index - b.index;
             })
             .map((entry) => entry.message));

package/src/providers/provider-instance-manager.ts

@@ -47,7 +47,10 @@ export class ProviderInstanceManager {
             this.instances.get(id)!.dispose();
         }
         this.instances.set(id, instance);
-        await instance.init(context);
+        await instance.init({
+            ...context,
+            emitProviderEvent: (event) => this.emitProviderEvent(instance.type, id, event),
+        });
     }
 
  /**
@@ -237,6 +240,22 @@ export class ProviderInstanceManager {
         this.eventListeners.push(listener);
     }
 
+    emitProviderEvent(providerType: string, instanceId: string, event: ProviderEvent): void {
+        const payload = {
+            ...event,
+            providerType,
+            instanceId: typeof event.instanceId === 'string' && event.instanceId.trim()
+                ? event.instanceId
+                : instanceId,
+            targetSessionId: typeof event.targetSessionId === 'string' && event.targetSessionId.trim()
+                ? event.targetSessionId
+                : instanceId,
+        } as ProviderEvent & { providerType: string };
+        for (const listener of this.eventListeners) {
+            listener(payload);
+        }
+    }
+
     private emitPendingEvents(
         providerType: string,
         state: ProviderState,

package/src/providers/provider-instance.ts

@@ -174,6 +174,8 @@ export interface InstanceContext {
     onPtyData?: (data: string) => void;
  /** Provider configvalue (resolved) */
     settings: Record<string, any>;
+ /** Immediate provider-originated status/event emission. Used to avoid waiting for status polling. */
+    emitProviderEvent?: (event: ProviderEvent) => void;
 }
 
 export interface ProviderInstance {

package/src/repo-mesh-types.ts

@@ -55,6 +55,8 @@ export type RepoMeshNodeHealth =
 
 // ─── Policy Types ───────────────────────────────
 
+export type RepoMeshSessionCleanupMode = 'preserve' | 'stop' | 'delete_stopped' | 'stop_and_delete';
+
 export interface RepoMeshPolicy {
     requirePreTaskCheckpoint: boolean;
     requirePostTaskCheckpoint: boolean;
@@ -63,12 +65,20 @@ export interface RepoMeshPolicy {
     dirtyWorkspaceBehavior: 'block' | 'warn' | 'checkpoint_then_continue';
     maxParallelTasks: number;
     allowedProviders?: string[];
+    /**
+     * What to do with delegated session-host records for a node when it is removed.
+     * Defaults to 'preserve' so completed work can be reviewed later and live
+     * runtimes are never stopped/deleted unless the mesh owner opts in.
+     */
+    sessionCleanupOnNodeRemove?: RepoMeshSessionCleanupMode;
 }
 
 export interface RepoMeshNodePolicy {
     readOnly?: boolean;
     canPush?: boolean;
     maxConcurrentSessions?: number;
+    /** Ordered provider preference used when mesh_launch_session omits an explicit type. */
+    providerPriority?: string[];
 }
 
 export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
@@ -78,6 +88,7 @@ export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
     requireApprovalForDestructiveGit: true,
     dirtyWorkspaceBehavior: 'warn',
     maxParallelTasks: 2,
+    sessionCleanupOnNodeRemove: 'preserve',
 };
 
 // ─── Capabilities ───────────────────────────────
@@ -189,6 +200,10 @@ export interface LocalMeshNodeEntry {
     policy: RepoMeshNodePolicy;
     /** For single-machine mesh: same daemon, different worktree */
     isLocalWorktree?: boolean;
+    /** Branch this worktree tracks (set when created via clone_mesh_node) */
+    worktreeBranch?: string;
+    /** Node ID this worktree was cloned from */
+    clonedFromNodeId?: string;
 }
 
 // ─── Mesh Status (runtime, not persisted) ───────

package/src/shared-types.ts

@@ -641,6 +641,8 @@ export interface DaemonStatusEventPayload {
     timestamp: number;
     targetSessionId?: string;
     providerType?: string;
+    providerSessionId?: string;
+    workspaceName?: string;
     duration?: number;
     elapsedSec?: number;
     modalMessage?: string;
@@ -662,6 +664,8 @@ export interface DashboardStatusEventPayload {
     daemonId?: string;
     providerType?: string;
     targetSessionId?: string;
+    providerSessionId?: string;
+    workspaceName?: string;
     duration?: number;
     elapsedSec?: number;
     modalMessage?: string;

package/src/status/builders.ts

@@ -43,6 +43,19 @@ function getActiveChatOptions(profile: SessionEntryProfile): NormalizeActiveChat
     return LIVE_STATUS_ACTIVE_CHAT_OPTIONS;
 }
 
+function resolveSessionStatus(
+    activeChat: { status?: string | null; activeModal?: { buttons?: unknown[] | null } | null } | null | undefined,
+    providerStatus?: string | null,
+) {
+    const chatStatus = normalizeManagedStatus(activeChat?.status, { activeModal: activeChat?.activeModal || null });
+    const topLevelStatus = normalizeManagedStatus(providerStatus, { activeModal: activeChat?.activeModal || null });
+
+    if (chatStatus === 'waiting_approval' || topLevelStatus === 'waiting_approval') return 'waiting_approval';
+    if (chatStatus === 'generating' || topLevelStatus === 'generating') return 'generating';
+    if (topLevelStatus !== 'idle') return topLevelStatus;
+    return chatStatus;
+}
+
 function shouldIncludeSessionControls(profile: SessionEntryProfile): boolean {
     return profile !== 'live';
 }
@@ -170,9 +183,7 @@ function buildIdeWorkspaceSession(
         providerName: state.name,
         kind: 'workspace',
         transport: 'cdp-page',
-        status: normalizeManagedStatus(activeChat?.status || state.status, {
-            activeModal: activeChat?.activeModal || null,
-        }),
+        status: resolveSessionStatus(activeChat, state.status),
         title,
         workspace,
         ...(git && { git }),
@@ -212,9 +223,7 @@ function buildExtensionAgentSession(
         providerSessionId: ext.providerSessionId,
         kind: 'agent',
         transport: 'cdp-webview',
-        status: normalizeManagedStatus(activeChat?.status || ext.status, {
-            activeModal: activeChat?.activeModal || null,
-        }),
+        status: resolveSessionStatus(activeChat, ext.status),
         title: activeChat?.title || ext.name,
         workspace,
         ...(git && { git }),
@@ -277,9 +286,7 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         providerSessionId: state.providerSessionId,
         kind: 'agent',
         transport: 'pty',
-        status: normalizeManagedStatus(activeChat?.status || state.status, {
-            activeModal: activeChat?.activeModal || null,
-        }),
+        status: resolveSessionStatus(activeChat, state.status),
         title: activeChat?.title || state.name,
         workspace,
         ...(git && { git }),
@@ -328,9 +335,7 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
         providerName: state.name,
         kind: 'agent',
         transport: 'acp',
-        status: normalizeManagedStatus(activeChat?.status || state.status, {
-            activeModal: activeChat?.activeModal || null,
-        }),
+        status: resolveSessionStatus(activeChat, state.status),
         title: activeChat?.title || state.name,
         workspace,
         ...(git && { git }),

package/src/status/reporter.ts

@@ -151,6 +151,12 @@ export class DaemonStatusReporter {
         if (providerType) {
             payload.providerType = providerType;
         }
+        if (typeof event.providerSessionId === 'string' && event.providerSessionId.trim()) {
+            payload.providerSessionId = event.providerSessionId.trim();
+        }
+        if (typeof event.workspaceName === 'string' && event.workspaceName.trim()) {
+            payload.workspaceName = event.workspaceName.trim();
+        }
         if (typeof event.duration === 'number' && Number.isFinite(event.duration)) {
             payload.duration = event.duration;
         }