@adhdev/daemon-core 0.9.82-rc.3 → 0.9.82-rc.300

package/src/repo-mesh-types.ts

@@ -12,6 +12,7 @@
  */
 
 import type { GitRepoStatus, GitCompactSummary } from './git/git-types.js';
+import type { MeshMissionSummary } from './mesh/mesh-missions.js';
 
 // ─── Core Mesh Types ────────────────────────────
 
@@ -23,11 +24,42 @@ export interface RepoMesh {
     defaultBranch?: string;
     policy: RepoMeshPolicy;
     coordinator: RepoMeshCoordinatorConfig;
+    meshHost?: RepoMeshHostMetadata;
     projectContext: ProjectContextSnapshot;
     nodes: RepoMeshNode[];
     status: 'active' | 'archived' | 'deleted';
 }
 
+export type RepoMeshDaemonRole = 'host' | 'member';
+
+export interface RepoMeshHostPairingMetadata {
+    status: 'not_configured' | 'pairing' | 'paired' | 'rejected' | 'revoked';
+    tokenId?: string;
+    joinedAt?: string;
+    lastPairedAt?: string;
+    lastRejectedAt?: string;
+    expiresAt?: string;
+}
+
+export interface RepoMeshHostMetadata {
+    /** Local daemon role for this mesh. Missing metadata defaults to host for standalone compatibility. */
+    role: RepoMeshDaemonRole;
+    /** Daemon that owns mesh truth/status/git/queue/session/ledger/coordinator ownership. */
+    hostDaemonId?: string;
+    /** Mesh node that represents the host daemon, when known. */
+    hostNodeId?: string;
+    /** Future standalone manual pairing endpoint entered by member daemons. */
+    hostAddress?: string;
+    /** Redacted pairing state only; raw join tokens must not be persisted here. */
+    pairing?: RepoMeshHostPairingMetadata;
+}
+
+export interface RepoMeshHostStatus extends RepoMeshHostMetadata {
+    canOwnCoordinator: boolean;
+    canOwnQueue: boolean;
+    defaulted: boolean;
+}
+
 export interface RepoMeshNode {
     id: string;
     daemonId: string;
@@ -42,6 +74,7 @@ export interface RepoMeshNode {
     effectiveCapabilities: RepoMeshNodeCapabilities;
     policy: RepoMeshNodePolicy;
     health: RepoMeshNodeHealth;
+    role?: RepoMeshDaemonRole;
     status: 'enabled' | 'disabled' | 'removed';
 }
 
@@ -58,10 +91,26 @@ export type RepoMeshNodeHealth =
 export type RepoMeshSessionCleanupMode = 'preserve' | 'stop' | 'delete_stopped' | 'stop_and_delete';
 export type RepoMeshSpawnedSessionVisibility = 'visible' | 'hidden';
 
+export interface RepoMeshAutoFastForwardPolicy {
+    /** Defaults to true. Set false to disable daemon-initiated idle fast-forwards. */
+    enabled: boolean;
+    /** Maximum behind count eligible for automatic fast-forward. Missing means no limit. */
+    maxBehind?: number;
+    /** Defaults to true. Require submodule status to be clean before automatic fast-forward. */
+    requireCleanSubmodules?: boolean;
+}
+
 export interface RepoMeshPolicy {
     requirePreTaskCheckpoint: boolean;
     requirePostTaskCheckpoint: boolean;
     requireApprovalForPush: boolean;
+    /**
+     * Narrow Refinery opt-in: when validation and patch-equivalence have passed,
+     * allow Refinery to publish submodule gitlink commits to each submodule's
+     * configured remote main branch with a non-force push, then verify reachability.
+     * Defaults to false; root branch pushes/merges are not affected.
+     */
+    allowAutoPublishSubmoduleMainCommits?: boolean;
     requireApprovalForDestructiveGit: boolean;
     dirtyWorkspaceBehavior: 'block' | 'warn' | 'checkpoint_then_continue';
     maxParallelTasks: number;
@@ -72,12 +121,28 @@ export interface RepoMeshPolicy {
      * watch-the-agents behavior; hidden sessions remain discoverable and manually openable.
      */
     spawnedSessionVisibility?: RepoMeshSpawnedSessionVisibility;
+    /**
+     * Whether worker sessions the coordinator dispatches should auto-approve agent
+     * approval modals (tool/command prompts) without firing a user-facing approval
+     * notification. Delegated workers are coordinator-driven, so a human should not
+     * have to approve each one; defaults to true. Set to false to make delegated
+     * worker sessions stop at approval modals like an interactive session.
+     * Stamped into the worker launch settings envelope as `autoApprove`, which wins
+     * over the global per-provider-type autoApprove config via the settings merge.
+     * A node policy may override this per-node (RepoMeshNodePolicy.delegatedWorkerAutoApprove).
+     */
+    delegatedWorkerAutoApprove?: boolean;
     /**
      * 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;
+    /**
+     * Daemon-initiated fast-forward for idle clean nodes that are only behind
+     * their tracked upstream. Defaults to enabled.
+     */
+    autoFastForward?: RepoMeshAutoFastForwardPolicy;
     /**
      * Maximum number of automatic retry recommendations for a failed task on the
      * same node before the daemon advises the coordinator to escalate or reassign.
@@ -93,12 +158,54 @@ export interface RepoMeshRelatedRepo {
     workspace: string;
 }
 
+/**
+ * Per-(node, provider) role + parallelism declaration.
+ *
+ * `role` is a free-form resource-pool label (recommended values:
+ * 'investigation' | 'coding' | 'orchestration') describing what this
+ * (node, provider) combination is *for*. It is a label/hint only — it is
+ * surfaced to the coordinator and dashboards but the daemon does NOT route
+ * tasks by role (task routing stays driven by taskMode + requiredTags +
+ * targetNode/targetSession). role is intentionally orthogonal to taskMode:
+ * taskMode classifies the *work* (code_change vs live_debug_readonly), role
+ * classifies the *resource pool*.
+ *
+ * `maxParallel` is the only enforced field: the queue will not assign a task
+ * to this (node, provider) once it already has `maxParallel` active
+ * (status='assigned') tasks. When the global parallel cap and this per-(node,
+ * provider) cap disagree, the stricter (lower effective) limit wins — a claim
+ * must satisfy both. Omitting `maxParallel` means this provider is bounded only
+ * by the global/taskMode caps (full backward compatibility).
+ */
+export interface RepoMeshProviderRole {
+    /** Provider type this entry governs (e.g. 'claude-cli', 'codex-cli'). */
+    providerType: string;
+    /** Free-form role label; recommended: 'investigation' | 'coding' | 'orchestration'. */
+    role?: string;
+    /** Max concurrent active tasks for this (node, provider). Omit = no per-provider cap. */
+    maxParallel?: number;
+}
+
 export interface RepoMeshNodePolicy {
     readOnly?: boolean;
     canPush?: boolean;
     maxConcurrentSessions?: number;
     /** Ordered provider preference used when mesh_launch_session omits an explicit type. */
     providerPriority?: string[];
+    /**
+     * Per-(node, provider) role + parallelism declarations. Each entry binds a
+     * providerType on THIS node to an optional free-form role label and an
+     * optional maxParallel cap. Only maxParallel is enforced (as an additional,
+     * stricter-wins constraint on top of the global maxParallelTasks/taskMode
+     * caps); role is a label/hint surfaced to the coordinator. Missing/empty:
+     * the node behaves exactly as before (global caps only).
+     */
+    providerRoles?: RepoMeshProviderRole[];
+    /**
+     * Per-node override for RepoMeshPolicy.delegatedWorkerAutoApprove. When set, takes
+     * precedence over the mesh-level policy for worker sessions launched onto this node.
+     */
+    delegatedWorkerAutoApprove?: boolean;
     /**
      * Optional associated/external repos that must be checked alongside this node.
      * These are explicit policy/config entries only; Repo Mesh does not auto-discover
@@ -126,14 +233,75 @@ export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
     requirePreTaskCheckpoint: false,
     requirePostTaskCheckpoint: true,
     requireApprovalForPush: true,
+    allowAutoPublishSubmoduleMainCommits: false,
     requireApprovalForDestructiveGit: true,
     dirtyWorkspaceBehavior: 'warn',
     maxParallelTasks: 2,
     spawnedSessionVisibility: 'visible',
+    delegatedWorkerAutoApprove: true,
     sessionCleanupOnNodeRemove: 'preserve',
+    autoFastForward: { enabled: true },
     maxTaskRetries: 1,
 };
 
+/**
+ * Resolve whether a delegated worker session launched onto `nodePolicy` (within a mesh
+ * governed by `meshPolicy`) should auto-approve. Precedence: node override → mesh policy
+ * → default true. The result is stamped into the worker launch settings envelope as
+ * `autoApprove`; it wins over the global per-provider-type autoApprove config because the
+ * launch path merges the envelope as a settingsOverride on top of the provider defaults.
+ */
+export function resolveDelegatedWorkerAutoApprove(
+    meshPolicy?: Pick<RepoMeshPolicy, 'delegatedWorkerAutoApprove'> | null,
+    nodePolicy?: Pick<RepoMeshNodePolicy, 'delegatedWorkerAutoApprove'> | null,
+): boolean {
+    if (typeof nodePolicy?.delegatedWorkerAutoApprove === 'boolean') {
+        return nodePolicy.delegatedWorkerAutoApprove;
+    }
+    if (typeof meshPolicy?.delegatedWorkerAutoApprove === 'boolean') {
+        return meshPolicy.delegatedWorkerAutoApprove;
+    }
+    return true;
+}
+
+/**
+ * Resolve the per-(node, provider) role declaration from a node policy.
+ * Case-insensitive, trimmed match on providerType. Returns undefined when the
+ * node has no providerRoles entry for this provider (caller then applies only
+ * the global caps). Defensive against malformed config — non-object entries and
+ * blank providerTypes are skipped rather than throwing.
+ */
+export function resolveProviderRole(
+    nodePolicy: Pick<RepoMeshNodePolicy, 'providerRoles'> | null | undefined,
+    providerType: string | null | undefined,
+): RepoMeshProviderRole | undefined {
+    const wanted = typeof providerType === 'string' ? providerType.trim().toLowerCase() : '';
+    if (!wanted) return undefined;
+    const roles = nodePolicy?.providerRoles;
+    if (!Array.isArray(roles)) return undefined;
+    for (const entry of roles) {
+        if (!entry || typeof entry !== 'object') continue;
+        const type = typeof entry.providerType === 'string' ? entry.providerType.trim().toLowerCase() : '';
+        if (type && type === wanted) return entry;
+    }
+    return undefined;
+}
+
+/**
+ * Resolve the enforced per-(node, provider) maxParallel cap, or undefined when
+ * no finite, non-negative cap is declared for this provider. Used by the queue
+ * claim path as a stricter-wins constraint layered on top of the global caps.
+ */
+export function resolveProviderMaxParallel(
+    nodePolicy: Pick<RepoMeshNodePolicy, 'providerRoles'> | null | undefined,
+    providerType: string | null | undefined,
+): number | undefined {
+    const role = resolveProviderRole(nodePolicy, providerType);
+    const raw = Number(role?.maxParallel);
+    if (!Number.isFinite(raw) || raw < 0) return undefined;
+    return Math.floor(raw);
+}
+
 // ─── Capabilities ───────────────────────────────
 
 export interface RepoMeshNodeCapabilities {
@@ -207,7 +375,28 @@ export interface RepoMeshCoordinatorConfig {
     providerType?: string;
     /** Preferred node to run coordinator on (null = auto) */
     preferredNodeId?: string;
-    /** Additional system prompt context for coordinator */
+    /**
+     * Full mesh-level override for the coordinator system prompt. When set,
+     * replaces the daemon's rendered default and any user-file override
+     * (~/.adhdev/coordinator-prompts/<cli>.md). The per-launch
+     * extraSystemPrompt still composes on top — it always lands last as
+     * Additional Context. Supports the same {{placeholders}} the daemon's
+     * default template uses ({{meshName}}, {{repo}}, {{nodes}}, …).
+     */
+    systemPromptOverride?: string;
+    /**
+     * Mesh-level append. Composes after whichever base prompt won
+     * (override → user-file override → daemon default). Use this when you
+     * want extra rules for THIS mesh but otherwise the standard prompt is
+     * fine. Stacks with the user-file append (`<cli>.append.md`) — both
+     * apply if both are set.
+     */
+    systemPromptAppend?: string;
+    /**
+     * @deprecated Use systemPromptAppend. Kept as a fallback alias so
+     * existing meshes.json files keep working without a migration step;
+     * the daemon prefers systemPromptAppend when both are present.
+     */
     systemPromptSuffix?: string;
 }
 
@@ -229,6 +418,7 @@ export interface LocalMeshEntry {
     defaultBranch?: string;
     policy: RepoMeshPolicy;
     coordinator: RepoMeshCoordinatorConfig;
+    meshHost?: RepoMeshHostMetadata;
     nodes: LocalMeshNodeEntry[];
     createdAt: string;
     updatedAt: string;
@@ -241,16 +431,42 @@ export interface LocalMeshNodeEntry {
     daemonId?: string;
     /** Machine registry ID that owns this workspace, when known. */
     machineId?: string;
+    /** Operator-defined capability tags used by mesh queue matching. */
+    capabilities?: string[];
     userOverrides: Partial<RepoMeshNodeCapabilities>;
     policy: RepoMeshNodePolicy;
+    /**
+     * Per-node instruction surfaced in the coordinator prompt so the LLM
+     * knows what each node is for (e.g. "this is the staging mirror — run
+     * only smoke tests here", or "use opus on this node, sonnet elsewhere").
+     * Empty/missing: omitted silently from the rendered prompt, no rule
+     * line about it gets added. The coordinator forwards/honors it when
+     * delegating; we don't enforce it at the daemon level.
+     */
+    systemPrompt?: string;
     /** 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;
+    /** Repo-local preparation result for ADHDev-created worktree nodes. */
+    worktreeBootstrap?: {
+        status: 'ready' | 'running' | 'failed' | 'not_configured' | 'disabled' | 'stale';
+        required?: boolean;
+        configSource?: string;
+        configSourceType?: string;
+        startedAt?: string;
+        completedAt?: string;
+        lastCommand?: string;
+        exitCode?: number | null;
+        error?: string;
+        commandsRun?: Array<Record<string, unknown>>;
+        staleInputs?: string[];
+    };
     /** Optional associated/external repos configured as node metadata. */
     relatedRepos?: RepoMeshRelatedRepo[];
+    role?: RepoMeshDaemonRole;
 }
 
 // ─── Mesh Status (runtime, not persisted) ───────
@@ -259,17 +475,178 @@ export interface RepoMeshStatus {
     meshId: string;
     meshName: string;
     repoIdentity: string;
+    defaultBranch?: string;
     refreshedAt: string;
+    meshHost?: RepoMeshHostStatus;
     nodes: RepoMeshNodeStatus[];
+    queue?: RepoMeshQueueStatus;
+    ledger?: RepoMeshLedgerStatus;
+    /**
+     * Mission summaries for the dashboard overview. Active/paused missions plus a
+     * capped, newest-first slice of completed/abandoned history. Omitted by older
+     * daemons — the dashboard must treat this as optional and render an empty
+     * state when absent. Split on each entry's `status` for live vs. history.
+     */
+    missions?: MeshMissionSummary[];
+}
+
+// RepoMeshSessionStatus shape now lives in @adhdev/mesh-shared (shared with
+// web-core's session normalizer). Re-exported so local RepoMeshNodeStatus/
+// RepoMeshStatus and external `@adhdev/daemon-core/repo-mesh-types` consumers
+// keep resolving it unchanged.
+export type { RepoMeshSessionStatus } from '@adhdev/mesh-shared';
+import type { RepoMeshSessionStatus } from '@adhdev/mesh-shared';
+
+export type RepoMeshPeerConnectionState = 'self' | 'connected' | 'connecting' | 'disconnected' | 'failed' | 'closed' | 'unknown';
+export type RepoMeshPeerConnectionTransport = 'local' | 'direct' | 'relay' | 'unknown';
+
+export interface RepoMeshPeerConnectionStatus {
+    perspective: 'selected_coordinator';
+    source: 'mesh_peer_status' | 'not_reported';
+    state: RepoMeshPeerConnectionState;
+    transport: RepoMeshPeerConnectionTransport;
+    reported: boolean;
+    reason?: string;
+    lastStateChangeAt?: string;
+    lastConnectedAt?: string;
+    lastCommandAt?: string;
 }
 
 export interface RepoMeshNodeStatus {
     nodeId: string;
     machineLabel: string;
     workspace: string;
+    repoRoot?: string;
+    daemonId?: string;
+    machineId?: string;
+    role?: RepoMeshDaemonRole;
+    machineStatus?: string;
+    isLocalWorktree?: boolean;
+    worktreeBranch?: string;
+    /** Mirrored from LocalMeshNodeEntry.systemPrompt for coordinator-prompt rendering. */
+    systemPrompt?: string;
     health: RepoMeshNodeHealth;
     git?: GitRepoStatus;
+    /**
+     * True when the selected coordinator has evidence that a peer git probe is still
+     * in flight or just timed out during initial mesh handshake, so callers should
+     * treat missing git data as pending instead of authoritative absence.
+     */
+    gitProbePending?: boolean;
     providers: string[];
     activeSessions: string[];
+    activeSessionDetails?: RepoMeshSessionStatus[];
+    providerPriority?: string[];
+    launchReady?: boolean;
+    /** True when the node is clean, ahead=0, behind>0, and safe for fast-forward consideration. */
+    autoFastForwardEligible?: boolean;
+    /** Coordinator-facing suggestion for obvious clean catch-up work. */
+    suggestedAction?: 'auto_fast_forward';
+    worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
+    launchBlockedReason?: string;
+    launchBlockedMessage?: string;
+    recoveryHint?: string;
+    lastSeenAt?: string;
+    updatedAt?: string;
+    connection?: RepoMeshPeerConnectionStatus;
+    error?: string;
+}
+
+export type RepoMeshQueueTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
+
+export interface RepoMeshQueueTask {
+    id: string;
+    meshId: string;
+    message: string;
+    status: RepoMeshQueueTaskStatus;
+    targetNodeId?: string;
+    targetSessionId?: string;
+    assignedNodeId?: string;
+    assignedSessionId?: string;
+    cancelReason?: string;
+    cancelledAt?: string;
+    requeueReason?: string;
+    requeuedAt?: string;
+    requeueCount?: number;
+    autoLaunch?: {
+        status: 'skipped' | 'started' | 'failed' | 'completed';
+        reason?: string;
+        nodeId?: string;
+        providerType?: string;
+        sessionId?: string;
+        updatedAt: string;
+    };
+    dispatchTimestamp?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export interface RepoMeshQueueSummary {
+    total: number;
+    active: number;
+    historical: number;
+    pending: number;
+    assigned: number;
+    completed: number;
+    failed: number;
+    cancelled: number;
+    activeCounts: {
+        pending: number;
+        assigned: number;
+    };
+    historicalCounts: {
+        completed: number;
+        failed: number;
+        cancelled: number;
+    };
+    activeAssignments: Array<{
+        id: string;
+        nodeId?: string;
+        sessionId?: string;
+        message: string;
+    }>;
+}
+
+export interface RepoMeshQueueStatus {
+    tasks: RepoMeshQueueTask[];
+    summary: RepoMeshQueueSummary;
+}
+
+export interface RepoMeshLedgerEntryStatus {
+    id: string;
+    meshId: string;
+    timestamp: string;
+    kind: string;
+    nodeId?: string;
+    sessionId?: string;
+    providerType?: string;
+    payload: Record<string, unknown>;
+}
+
+export interface RepoMeshLedgerSummaryStatus {
+    meshId: string;
+    totalEntries: number;
+    taskDispatched: number;
+    taskCompleted: number;
+    taskFailed: number;
+    taskStalled: number;
+    sessionLaunched: number;
+    checkpointCreated: number;
+    lastActivityAt: string | null;
+    recentFailures: number;
+}
+
+export interface RepoMeshLedgerStatus {
+    entries: RepoMeshLedgerEntryStatus[];
+    summary: RepoMeshLedgerSummaryStatus;
+}
+
+// ─── Async Job Lifecycle ─────────────────────────
+// Shared base for all mesh async job types (refine jobs, bootstrap runs, etc.)
+// Each concrete type adds its own status enum and domain-specific fields.
+
+export interface MeshAsyncJobLifecycle {
+    startedAt?: string;
+    completedAt?: string;
     error?: string;
 }

package/src/sessions/registry.ts

@@ -8,6 +8,12 @@ export interface SessionRuntimeTarget {
     cdpManagerKey?: string;
     adapterKey?: string;
     instanceKey?: string;
+    /** Working directory for CLI/ACP sessions. Used by read_chat to resolve
+     *  native history when there is no live adapter (e.g. subscription path). */
+    workspace?: string;
+    /** Wall clock at register time. native-history readers use it as a
+     *  cutoff so a fresh session can't show records from a prior one. */
+    spawnedAtMs?: number;
 }
 
 export class SessionRegistry {

package/src/shared-types-extra.ts

@@ -21,14 +21,12 @@ export interface RuntimeAttachedClient {
 }
 
 /** Session status union (used by SessionEntry.status, legacy recent-launch metadata, etc.) */
-export type SessionStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
+export type SessionStatus = 'idle' | 'generating' | 'waiting_approval' | 'waiting_choice' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
 
 /** Inbox bucket categories for recent sessions */
 export type RecentSessionBucket = 'needs_attention' | 'working' | 'task_complete' | 'idle';
 
 /** Terminal backend status */
 export interface TerminalBackendStatus {
-    backend: 'xterm' | 'ghostty-vt';
-    preference: 'auto' | 'xterm' | 'ghostty-vt';
-    ghosttyAvailable: boolean;
+    backend: 'ghostty-vt';
 }

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;