@adhdev/daemon-core 0.9.82-rc.17 → 0.9.82-rc.170

package/src/shared-types.ts

@@ -56,6 +56,7 @@ import type {
     GitWorkspaceUpdate,
     WorkspaceGitSubscriptionParams,
 } from './git/git-types.js';
+import type { InteractivePrompt } from './providers/types/interactive-prompt.js';
 
 export type {
     GitCommandName,
@@ -110,6 +111,14 @@ export interface ReadChatSyncResult {
     status: string;
     title?: string;
     activeModal?: { message: string; buttons: string[] } | null;
+    activeInteractivePrompt?: InteractivePrompt | null;
+    /**
+     * Chat source provenance from ChatSourceMachine (A2). Carries the
+     * selected source, transition cause, lock state, and legacy
+     * fallbackReason — opaque to the daemon-core, consumed by web-core
+     * for the source debug badge and SourceTimeline (A3).
+     */
+    messageSource?: Record<string, unknown>;
 }
 
 export interface ProviderSummaryItem {
@@ -365,6 +374,7 @@ export interface SessionEntry {
     runtimeRecoveryState?: string | null;
     resume?: ProviderResumeCapability;
     activeChat: SessionActiveChatData | null;
+    activeInteractivePrompt?: InteractivePrompt | null;
     capabilities?: SessionCapability[];
     /** Effective message input/media support for this session. Defaults fail-closed to text-only. */
     messageInput?: MessageInputSupport;
@@ -389,6 +399,8 @@ export interface SessionEntry {
     seenCompletionMarker?: string;
     surfaceHidden?: boolean;
     settings?: Record<string, any>;
+    /** Set when this session is acting as a mesh coordinator for the given mesh. */
+    coordinator?: { meshId: string; role: 'coordinator' };
     meshQueueStats?: {
         total?: number;
         active?: number;
@@ -516,7 +528,39 @@ export interface AvailableProviderInfo {
     lastVerification?: MachineProviderCheckResult;
     /** Provider-declared Repo Mesh coordinator/MCP behavior. */
     meshCoordinator?: ProviderMeshCoordinatorConfig;
-}
+    /**
+     * Provider trust classification — derived from the on-disk layer the
+     * manifest came from and the shape of the manifest. Dashboards use
+     * this to render a trust badge and gate activation of
+     * `external-untrusted` providers behind a confirm modal.
+     */
+    trust?: ProviderTrust;
+    /** Daemon-side human-readable description of the trust value. */
+    trustDescription?: string;
+    /** True when activation needs a user-side confirmation step. */
+    requiresConfirmation?: boolean;
+    /** Which on-disk layer the manifest lives in. */
+    sourceLayer?: 'user' | 'upstream' | 'external';
+    /** For external providers, the source-name namespace it came from. */
+    sourceName?: string | null;
+    /** Manifest-declared version, e.g. "1.2.1". */
+    providerVersion?: string;
+    /** Underlying executable name (CLI/binary providers). */
+    binary?: string;
+    /** Lifecycle label from the manifest: "Stable", "Beta", … */
+    status?: string;
+    /** One-line provider description from the manifest. */
+    details?: string;
+    /** Manifest-declared links: homepage, docs, repo, … */
+    links?: Record<string, string>;
+}
+
+export type ProviderTrust =
+    | 'user-custom'
+    | 'trusted'
+    | 'trusted-with-scripts'
+    | 'external-safe'
+    | 'external-untrusted';
 
 export interface MachineProviderCheckResult {
     ok: boolean;

package/src/status/builders.ts

@@ -25,6 +25,7 @@ import {
     type NormalizeActiveChatOptions,
 } from './normalize.js';
 import { getMeshQueueStats } from '../mesh/mesh-work-queue.js';
+import { getCoordinatorForSession } from '../mesh/coordinator-registry.js';
 import { normalizeProviderStateControlValues } from '../providers/provider-patch-state.js';
 import { normalizeProviderSummaryMetadata } from '../providers/summary-metadata.js';
 import {
@@ -164,7 +165,7 @@ const ACP_SESSION_CAPABILITIES: SessionCapability[] = [
     'set_thought_level',
 ];
 
-function buildIdeWorkspaceSession(
+function buildWorkspaceSession(
     state: IdeProviderState,
     cdpManagers: Map<string, DaemonCdpManager>,
     options: SessionEntryBuildOptions,
@@ -179,7 +180,10 @@ function buildIdeWorkspaceSession(
     const git = getGitSummaryForWorkspace(workspace, options);
     const title = activeChat?.title || state.name;
     const meshCoordinatorFor = state.settings?.meshCoordinatorFor as string | undefined;
-    const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : undefined;
+    const registryEntry = state.instanceId ? getCoordinatorForSession(state.instanceId) : undefined;
+    const effectiveMeshId = meshCoordinatorFor || registryEntry?.meshId;
+    const coordinator = effectiveMeshId ? { meshId: effectiveMeshId, role: 'coordinator' as const } : undefined;
+    const meshQueueStats = effectiveMeshId ? getMeshQueueStats(effectiveMeshId) : undefined;
     return {
         id: state.instanceId || state.type,
         parentId: null,
@@ -203,6 +207,7 @@ function buildIdeWorkspaceSession(
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
         settings: state.settings,
+        ...(coordinator && { coordinator }),
         ...(meshQueueStats && { meshQueueStats }),
     };
 }
@@ -221,7 +226,10 @@ function buildExtensionAgentSession(
     const workspace = parent.workspace || null;
     const git = getGitSummaryForWorkspace(workspace, options);
     const meshCoordinatorFor = ext.settings?.meshCoordinatorFor as string | undefined;
-    const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : undefined;
+    const registryEntry = ext.instanceId ? getCoordinatorForSession(ext.instanceId) : undefined;
+    const effectiveMeshId = meshCoordinatorFor || registryEntry?.meshId;
+    const coordinator = effectiveMeshId ? { meshId: effectiveMeshId, role: 'coordinator' as const } : undefined;
+    const meshQueueStats = effectiveMeshId ? getMeshQueueStats(effectiveMeshId) : undefined;
     return {
         id: ext.instanceId || `${parent.instanceId}:${ext.type}`,
         parentId: parent.instanceId || parent.type,
@@ -245,6 +253,7 @@ function buildExtensionAgentSession(
         errorReason: ext.errorReason,
         lastUpdated: ext.lastUpdated,
         settings: ext.settings,
+        ...(coordinator && { coordinator }),
         ...(meshQueueStats && { meshQueueStats }),
     };
 }
@@ -287,7 +296,10 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
     const workspace = state.workspace || null;
     const git = getGitSummaryForWorkspace(workspace, options);
     const meshCoordinatorFor = state.settings?.meshCoordinatorFor as string | undefined;
-    const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : undefined;
+    const registryEntry = state.instanceId ? getCoordinatorForSession(state.instanceId) : undefined;
+    const effectiveMeshId = meshCoordinatorFor || registryEntry?.meshId;
+    const coordinator = effectiveMeshId ? { meshId: effectiveMeshId, role: 'coordinator' as const } : undefined;
+    const meshQueueStats = effectiveMeshId ? getMeshQueueStats(effectiveMeshId) : undefined;
     return {
         id: state.instanceId,
         parentId: null,
@@ -314,6 +326,7 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         mode: state.mode,
         resume: state.resume,
         activeChat,
+        ...(state.activeInteractivePrompt ? { activeInteractivePrompt: state.activeInteractivePrompt } : {}),
         ...(summaryMetadata && { summaryMetadata }),
         ...(includeSessionMetadata && {
             capabilities: state.mode === 'terminal' ? PTY_SESSION_CAPABILITIES : CLI_CHAT_SESSION_CAPABILITIES,
@@ -327,6 +340,7 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
         settings: state.settings,
+        ...(coordinator && { coordinator }),
         ...(meshQueueStats && { meshQueueStats }),
     };
 }
@@ -341,7 +355,10 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
     const workspace = state.workspace || null;
     const git = getGitSummaryForWorkspace(workspace, options);
     const meshCoordinatorFor = state.settings?.meshCoordinatorFor as string | undefined;
-    const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : undefined;
+    const registryEntry = state.instanceId ? getCoordinatorForSession(state.instanceId) : undefined;
+    const effectiveMeshId = meshCoordinatorFor || registryEntry?.meshId;
+    const coordinator = effectiveMeshId ? { meshId: effectiveMeshId, role: 'coordinator' as const } : undefined;
+    const meshQueueStats = effectiveMeshId ? getMeshQueueStats(effectiveMeshId) : undefined;
     return {
         id: state.instanceId,
         parentId: null,
@@ -364,6 +381,7 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
         settings: state.settings,
+        ...(coordinator && { coordinator }),
         ...(meshQueueStats && { meshQueueStats }),
     };
 }
@@ -380,7 +398,7 @@ export function buildSessionEntries(
     const acpStates = allStates.filter((s): s is AcpProviderState => s.category === 'acp');
 
     for (const state of ideStates) {
-        sessions.push(buildIdeWorkspaceSession(state, cdpManagers, options));
+        sessions.push(buildWorkspaceSession(state, cdpManagers, options));
         for (const ext of state.extensions as ExtensionProviderState[]) {
             if (!shouldIncludeExtensionSession(ext)) continue;
             sessions.push(buildExtensionAgentSession(state, ext, options));

package/src/status/reporter.ts

@@ -51,6 +51,8 @@ export class DaemonStatusReporter {
     private lastStatusSentAt = 0;
     private statusPendingThrottle = false;
     private lastP2PStatusHash = '';
+    private lastP2PStatusSentAt: number = 0;
+    private p2pDebounceTimer: ReturnType<typeof setTimeout> | null = null;
     private lastServerStatusHash = '';
     private lastStatusSummary = '';
 
@@ -355,7 +357,20 @@ export class DaemonStatusReporter {
             : { ...hashTarget, sessions };
         const h = this.simpleHash(JSON.stringify(hashPayload));
         if (h !== this.lastP2PStatusHash) {
+            const now = Date.now();
+            // Rate limit: max 1 per 500ms
+            if (this.lastP2PStatusSentAt && now - this.lastP2PStatusSentAt < 500) {
+                if (!this.p2pDebounceTimer) {
+                    this.p2pDebounceTimer = setTimeout(() => {
+                        this.p2pDebounceTimer = null;
+                        this.sendUnifiedStatusReport({ reason: 'p2p_debounce' });
+                    }, 500);
+                }
+                return false; // Dropped for now, but will trigger later
+            }
+            
             this.lastP2PStatusHash = h;
+            this.lastP2PStatusSentAt = now;
             this.deps.p2p?.sendStatus(payload);
             return true;
         }

package/src/status/snapshot.ts

@@ -145,21 +145,56 @@ function buildAvailableProviders(
         lastDetection?: AvailableProviderInfo['lastDetection'];
         lastVerification?: AvailableProviderInfo['lastVerification'];
         meshCoordinator?: AvailableProviderInfo['meshCoordinator'];
+        _sourceTrust?: AvailableProviderInfo['trust'];
+        _sourceLayer?: AvailableProviderInfo['sourceLayer'];
+        _sourceName?: string | null;
+        providerVersion?: string;
+        binary?: string;
+        status?: string;
+        details?: string;
+        links?: Record<string, string>;
     }> = providerLoader.getAvailableProviderInfos?.() || providerLoader.getAll();
-    return providers.map((provider) => ({
-        type: provider.type,
-        name: provider.displayName || provider.type,
-        displayName: provider.displayName || provider.type,
-        icon: provider.icon || '💻',
-        category: provider.category,
-        ...(provider.installed !== undefined ? { installed: provider.installed } : {}),
-        ...(provider.detectedPath !== undefined ? { detectedPath: provider.detectedPath } : {}),
-        ...(provider.enabled !== undefined ? { enabled: provider.enabled } : {}),
-        ...(provider.machineStatus !== undefined ? { machineStatus: provider.machineStatus } : {}),
-        ...(provider.lastDetection !== undefined ? { lastDetection: provider.lastDetection } : {}),
-        ...(provider.lastVerification !== undefined ? { lastVerification: provider.lastVerification } : {}),
-        ...(provider.meshCoordinator !== undefined ? { meshCoordinator: provider.meshCoordinator } : {}),
-    }));
+    // Trust helpers come from daemon-core; resolve them lazily so the
+    // status snapshot path stays loadable in older bundles that don't
+    // ship provider-trust yet.
+    let describeTrust: (trust: AvailableProviderInfo['trust']) => string = () => '';
+    let requiresConfirmation: (trust: AvailableProviderInfo['trust']) => boolean = () => false;
+    try {
+        const mod = require('../providers/provider-trust.js') as typeof import('../providers/provider-trust.js');
+        describeTrust = mod.describeTrust as typeof describeTrust;
+        requiresConfirmation = mod.requiresConfirmation as typeof requiresConfirmation;
+    } catch { /* enrichment only */ }
+    return providers.map((provider) => {
+        const trust = (provider as any)._sourceTrust as AvailableProviderInfo['trust'] | undefined;
+        const sourceLayer = (provider as any)._sourceLayer as AvailableProviderInfo['sourceLayer'] | undefined;
+        const sourceName = (provider as any)._sourceName as string | null | undefined;
+        return {
+            type: provider.type,
+            name: provider.displayName || provider.type,
+            displayName: provider.displayName || provider.type,
+            icon: provider.icon || '💻',
+            category: provider.category,
+            ...(provider.installed !== undefined ? { installed: provider.installed } : {}),
+            ...(provider.detectedPath !== undefined ? { detectedPath: provider.detectedPath } : {}),
+            ...(provider.enabled !== undefined ? { enabled: provider.enabled } : {}),
+            ...(provider.machineStatus !== undefined ? { machineStatus: provider.machineStatus } : {}),
+            ...(provider.lastDetection !== undefined ? { lastDetection: provider.lastDetection } : {}),
+            ...(provider.lastVerification !== undefined ? { lastVerification: provider.lastVerification } : {}),
+            ...(provider.meshCoordinator !== undefined ? { meshCoordinator: provider.meshCoordinator } : {}),
+            ...(trust ? {
+                trust,
+                trustDescription: describeTrust(trust),
+                requiresConfirmation: requiresConfirmation(trust),
+            } : {}),
+            ...(sourceLayer ? { sourceLayer } : {}),
+            ...(sourceName ? { sourceName } : {}),
+            ...(provider.providerVersion ? { providerVersion: provider.providerVersion } : {}),
+            ...(provider.binary ? { binary: provider.binary } : {}),
+            ...(provider.status ? { status: provider.status } : {}),
+            ...(provider.details ? { details: provider.details } : {}),
+            ...(provider.links ? { links: provider.links } : {}),
+        };
+    });
 }
 
 export function buildMachineInfo(profile: 'full' | 'live' | 'metadata' = 'full'): MachineInfo {
@@ -297,18 +332,30 @@ export function getSessionCompletionMarker(session: {
             receivedAt?: number | string;
             timestamp?: number | string;
             _turnKey?: string;
+            kind?: string;
         }> | null
     } | null
 }) {
-    const lastMessage = session.activeChat?.messages?.at?.(-1);
-    if (!lastMessage) return '';
-    const role = typeof lastMessage.role === 'string' ? lastMessage.role : '';
-    if (role === 'user' || role === 'human' || role === 'system') return '';
-    if (typeof lastMessage._turnKey === 'string' && lastMessage._turnKey) return `turn:${lastMessage._turnKey}`;
-    if (typeof lastMessage.id === 'string' && lastMessage.id) return `id:${lastMessage.id}`;
-    if (typeof lastMessage.index === 'number' && Number.isFinite(lastMessage.index)) return `idx:${lastMessage.index}`;
-    const timestamp = getMessageEventTime(lastMessage);
-    return timestamp > 0 ? `ts:${timestamp}` : '';
+    const messages = session.activeChat?.messages;
+    if (!Array.isArray(messages) || messages.length === 0) return '';
+    // Walk backwards until we find an assistant message that's not a tool call,
+    // or a user/human message (which ends the turn). System messages and tool
+    // messages don't gate "task completion" — they can't be acknowledged
+    // independently and rotate too aggressively for marker-based bell clearing.
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const m = messages[i];
+        const role = typeof m?.role === 'string' ? m.role : '';
+        const kind = typeof m?.kind === 'string' ? m.kind : '';
+        if (role === 'user' || role === 'human') return '';
+        if (role === 'system') continue;
+        if (kind === 'tool') continue;
+        if (typeof m._turnKey === 'string' && m._turnKey) return `turn:${m._turnKey}`;
+        if (typeof m.id === 'string' && m.id) return `id:${m.id}`;
+        if (typeof m.index === 'number' && Number.isFinite(m.index)) return `idx:${m.index}`;
+        const timestamp = getMessageEventTime(m);
+        return timestamp > 0 ? `ts:${timestamp}` : '';
+    }
+    return '';
 }
 
 function getSessionLastUsedAt(session: {
@@ -347,9 +394,21 @@ function getUnreadState(
     if (status === 'generating' || status === 'starting') {
         return { unread: false, inboxBucket: 'working' };
     }
+    // Read-state resolution:
+    // - When provider supplies a `completionMarker`, prefer marker-equality.
+    //   But if `seenCompletionMarker` hasn't been recorded yet (legacy/transition
+    //   case), fall back to timestamp comparison so a stale marker doesn't keep
+    //   the bell lit after the user already viewed the conversation.
+    // - When there is no completionMarker, use timestamp + role guard.
+    // - Trailing `assistant.tool` turns no longer count as unread on their own
+    //   — the human can't acknowledge a tool call separately from the answer,
+    //   so they'd be stuck with a perpetually unread badge.
+    const ignorableTrailingRoles = lastRole === 'user' || lastRole === 'human' || lastRole === 'system' || lastRole === 'tool';
     const unread = completionMarker
-        ? completionMarker !== seenCompletionMarker
-        : hasContentChange && lastUsedAt > lastSeenAt && lastRole !== 'user' && lastRole !== 'human' && lastRole !== 'system';
+        ? (seenCompletionMarker
+            ? completionMarker !== seenCompletionMarker
+            : hasContentChange && lastUsedAt > lastSeenAt && !ignorableTrailingRoles)
+        : hasContentChange && lastUsedAt > lastSeenAt && !ignorableTrailingRoles;
     return { unread, inboxBucket: unread ? 'task_complete' : 'idle' };
 }
 

package/src/system/host-memory.ts

@@ -11,7 +11,10 @@
  */
 
 import * as os from 'os';
-import { execSync } from 'child_process';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
 
 export interface HostMemorySnapshot {
     totalMem: number;
@@ -21,19 +24,22 @@ export interface HostMemorySnapshot {
     availableMem: number;
 }
 
-function parseDarwinAvailableBytes(totalMem: number): number | null {
-    if (os.platform() !== 'darwin') return null;
+let cachedDarwinAvail: number | null = null;
+let darwinMemoryInterval: NodeJS.Timeout | null = null;
+
+async function updateDarwinMemoryCache() {
+    if (os.platform() !== 'darwin') return;
     try {
-        const out = execSync('vm_stat', {
+        const { stdout } = await execAsync('vm_stat', {
             encoding: 'utf-8',
             timeout: 4000,
             maxBuffer: 256 * 1024,
         });
-        const pageSizeMatch = out.match(/page size of (\d+)\s*bytes/i);
+        const pageSizeMatch = stdout.match(/page size of (\d+)\s*bytes/i);
         const pageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : 4096;
 
         const counts: Record<string, number> = {};
-        for (const line of out.split('\n')) {
+        for (const line of stdout.split('\n')) {
             const m = line.match(/^\s*Pages\s+([^:]+):\s+([\d,]+)\s*\.?/);
             if (!m) continue;
             const key = m[1].trim().toLowerCase().replace(/\s+/g, '_');
@@ -49,17 +55,28 @@ function parseDarwinAvailableBytes(totalMem: number): number | null {
 
         const availPages = free + inactive + speculative + purgeable + fileBacked;
         const bytes = availPages * pageSize;
-        if (!Number.isFinite(bytes) || bytes < 0) return null;
-        return Math.min(bytes, totalMem);
+        cachedDarwinAvail = Number.isFinite(bytes) && bytes >= 0 ? Math.min(bytes, os.totalmem()) : null;
     } catch {
-        return null;
+        // silently fallback
     }
 }
 
 export function getHostMemorySnapshot(): HostMemorySnapshot {
+    if (os.platform() === 'darwin' && !darwinMemoryInterval) {
+        updateDarwinMemoryCache();
+        darwinMemoryInterval = setInterval(updateDarwinMemoryCache, 3000);
+        darwinMemoryInterval.unref();
+    }
+
     const totalMem = os.totalmem();
     const freeMem = os.freemem();
-    const darwinAvail = parseDarwinAvailableBytes(totalMem);
-    const availableMem = darwinAvail != null ? darwinAvail : freeMem;
-    return { totalMem, freeMem, availableMem };
+    const availableMem = os.platform() === 'darwin'
+        ? (cachedDarwinAvail ?? freeMem)
+        : freeMem;
+
+    return {
+        totalMem,
+        freeMem,
+        availableMem,
+    };
 }

package/src/types.ts

@@ -43,6 +43,11 @@ export interface ChatMessage {
   index?: number;
   timestamp?: number;
   receivedAt?: number;
+  /** (A2.3) Monotonic sequence number per (session, source). Producer-asserted
+   *  when emitted by v2-aware providers (transcript v2 schema); otherwise
+   *  derived by the daemon from receivedAt/timestamp/index. ChatSourceMachine
+   *  uses this as the native peak watermark for regression detection. */
+  sequence?: number;
   _turnKey?: string;
   /** Tool calls associated with this message */
   toolCalls?: ToolCallInfo[];