@adhdev/mesh-shared 1.0.82-rc.22 → 1.0.82-rc.24

package/dist/launch-defaults.d.ts

@@ -51,7 +51,7 @@ export interface LaunchDefaultAxis {
     defaultRef?: LaunchDefaultRef;
 }
 export type LaunchDefaultWarning = 'catalog_unverified' | 'manual_mcp_setup_required';
-export type LaunchDefaultValidationReason = 'invalid_schema' | 'provider_unknown' | 'provider_not_cli' | 'provider_disabled' | 'provider_not_detected' | 'provider_not_eligible' | 'model_unsupported' | 'model_provider_mismatch' | 'model_not_offered' | 'thinking_unsupported' | 'thinking_not_offered' | 'catalog_unavailable';
+export type LaunchDefaultValidationReason = 'invalid_schema' | 'provider_unknown' | 'provider_not_cli' | 'provider_disabled' | 'provider_not_detected' | 'provider_not_eligible' | 'provider_quota_gated' | 'model_unsupported' | 'model_provider_mismatch' | 'model_not_offered' | 'thinking_unsupported' | 'thinking_not_offered' | 'catalog_unavailable';
 export type LaunchDefaultResolution = {
     ok: true;
     selection: LaunchDefaultSelection;

package/dist/mesh-tool-names.d.ts

@@ -18,10 +18,10 @@
  * Order mirrors mcp-server `ALL_MESH_TOOLS` for easy visual diffing, but the consistency
  * checks are set-based (order-insensitive).
  */
-export declare const CANONICAL_MESH_TOOL_NAMES: readonly ["mesh_status", "mesh_route_preview", "mesh_list_nodes", "mesh_enqueue_batch", "mesh_enqueue_task", "mesh_view_queue", "mesh_queue_cancel", "mesh_queue_requeue", "mesh_send_task", "mesh_read_chat", "mesh_read_debug", "mesh_read_terminal", "mesh_send_keys", "mesh_launch_session", "mesh_git_status", "mesh_read_node_logs", "mesh_fast_forward_node", "mesh_restart_daemon", "mesh_checkpoint", "mesh_approve", "mesh_answer_question", "mesh_list_pending_approvals", "mesh_create", "mesh_add_node", "mesh_attach_remote", "mesh_clone_node", "mesh_remove_node", "mesh_cleanup_worktree_nodes", "mesh_refine_node", "mesh_refine_batch", "mesh_config", "mesh_init", "mesh_cleanup_sessions", "mesh_task_history", "mesh_ledger_query", "mesh_note", "mesh_reconcile_ledger", "mesh_mission_upsert", "mesh_mission_list", "mesh_review_inbox", "mesh_node_slots"];
+export declare const CANONICAL_MESH_TOOL_NAMES: readonly ["mesh_status", "mesh_route_preview", "mesh_list_nodes", "mesh_enqueue_batch", "mesh_enqueue_task", "mesh_view_queue", "mesh_queue_cancel", "mesh_queue_requeue", "mesh_send_task", "mesh_read_chat", "mesh_read_debug", "mesh_read_terminal", "mesh_send_keys", "mesh_launch_session", "mesh_git_status", "mesh_read_node_logs", "mesh_fast_forward_node", "mesh_restart_daemon", "mesh_checkpoint", "mesh_approve", "mesh_answer_question", "mesh_list_pending_approvals", "mesh_create", "mesh_add_node", "mesh_attach_remote", "mesh_clone_node", "mesh_remove_node", "mesh_cleanup_worktree_nodes", "mesh_refine_node", "mesh_refine_batch", "mesh_config", "mesh_init", "mesh_cleanup_sessions", "mesh_task_history", "mesh_ledger_query", "mesh_note", "mesh_reconcile_ledger", "mesh_mission_upsert", "mesh_mission_list", "mesh_review_inbox", "mesh_node_slots", "driver_list", "driver_describe", "artifact_list"];
 export type CanonicalMeshToolName = typeof CANONICAL_MESH_TOOL_NAMES[number];
 /** The count the `NN tools` barrel doc comments and consistency test assert against. */
-export declare const CANONICAL_MESH_TOOL_COUNT: 41;
+export declare const CANONICAL_MESH_TOOL_COUNT: 44;
 /**
  * Tool names retired by the 2026-09-26 tool-surface consolidation (60 → 48).
  * Every capability behind them is still reachable: each retired name maps to the

package/dist/outbound-message.d.ts

@@ -203,3 +203,10 @@ export declare function isSubmitOutcome(value: unknown): value is SubmitOutcome;
 export declare function isInputEnvelopeWire(value: unknown): value is InputEnvelopeWire;
 /** Minimal structural check for the wire boundary — not a full decoder (mesh-shared stays a pure leaf; semantic validation stays with the handler that owns it). */
 export declare function isOutboundMessage(value: unknown): value is OutboundMessage;
+/**
+ * Drop the `<pasted_content>` envelope lines Claude Code wraps around a pasted
+ * input. Only a text that OPENS with the envelope is touched; anything else is
+ * returned unchanged. Shared across daemon transcript merge and web echo/display
+ * normalization so wrapped turns correlate identically.
+ */
+export declare function unwrapPastedContent(text: string): string;

package/dist/protocol/daemon-server.d.ts

@@ -213,11 +213,15 @@ export type P2POfferWirePayload = {
     sdp: string;
     type: string;
     peerId: string;
+    attemptId?: number;
+    attemptEpoch?: string;
 };
 export type P2PIceWirePayload = {
     candidate: string;
     mid: string;
     peerId: string;
+    attemptId?: number;
+    attemptEpoch?: string;
 };
 /**
  * A dashboard-originated signal as relayed to the daemon. `peerId` is stamped
@@ -229,6 +233,8 @@ export type P2PIceWirePayload = {
 export type RelayedP2PSignalWirePayload = {
     peerId?: string;
     daemonId?: string;
+    attemptId?: number;
+    attemptEpoch?: string;
     sharePermission?: string;
     shareTargetSessionId?: string;
     sdp?: string;

package/dist/protocol/dashboard-daemon-p2p.d.ts

@@ -34,7 +34,7 @@ export type ChunkFrame<T extends string> = {
 export declare function isChunkType(value: unknown): value is `${string}_chunk`;
 export declare const DASHBOARD_TO_DAEMON_P2P_TYPES: readonly ["ping", "pong", "command", "input", "pty_input", "pty_resize", "screenshot_start", "screenshot_stop", "subscribe", "unsubscribe", "seqscribe_session_interest", "read", "write", "list"];
 export type DashboardToDaemonP2PType = typeof DASHBOARD_TO_DAEMON_P2P_TYPES[number];
-export declare const isDashboardToDaemonP2PType: (value: unknown) => value is "list" | "command" | "ping" | "pong" | "input" | "pty_input" | "pty_resize" | "screenshot_start" | "screenshot_stop" | "subscribe" | "unsubscribe" | "seqscribe_session_interest" | "read" | "write";
+export declare const isDashboardToDaemonP2PType: (value: unknown) => value is "read" | "list" | "command" | "ping" | "pong" | "input" | "pty_input" | "pty_resize" | "screenshot_start" | "screenshot_stop" | "subscribe" | "unsubscribe" | "seqscribe_session_interest" | "write";
 export type DashboardToDaemonChunkType = `${DashboardToDaemonP2PType}_chunk`;
 export declare function isDashboardToDaemonChunkType(value: unknown): value is DashboardToDaemonChunkType;
 export type P2PPingMsg = {

package/dist/protocol/dashboard-server.d.ts

@@ -109,12 +109,16 @@ export type SystemAnnouncementWirePayload = {
 export type DashboardP2POfferWirePayload = {
     daemonId: string;
     peerId?: string;
+    attemptId?: number;
+    attemptEpoch?: string;
     sdp: string;
     type: string;
 };
 export type DashboardP2PIceWirePayload = {
     daemonId: string;
     peerId?: string;
+    attemptId?: number;
+    attemptEpoch?: string;
     candidate: string;
     mid?: string;
     sdpMid?: string | null;
@@ -154,16 +158,22 @@ export declare const isDashboardP2PSignalType: (value: unknown) => value is "p2p
 export type DashboardP2PReadyWirePayload = {
     daemonId: string;
     peerId: string;
+    attemptId?: number;
+    attemptEpoch?: string;
 };
 export type DashboardP2PAnswerWirePayload = {
     daemonId: string;
     peerId: string;
     sdp: string;
     type: string;
+    attemptId?: number;
+    attemptEpoch?: string;
 };
 export type DashboardP2PLocalIceWirePayload = {
     daemonId: string;
     peerId: string;
+    attemptId?: number;
+    attemptEpoch?: string;
     candidate: string;
     sdpMid: string | null;
     sdpMLineIndex: number | null;

package/dist/role-launch.d.ts

@@ -0,0 +1,11 @@
+/** Persisted role-launch intent. Restart replays this selection rather than
+ * consulting newer machine defaults; restore preserves its original provenance. */
+import { type LaunchDefaultRole, type LaunchDefaultSelection, type LaunchDefaultAxis, type LaunchDefaultRef } from './launch-defaults';
+export interface RoleLaunchSelection {
+    role: LaunchDefaultRole;
+    selection: LaunchDefaultSelection;
+    applied: Record<keyof LaunchDefaultSelection, LaunchDefaultAxis>;
+    defaultRef?: LaunchDefaultRef;
+    documentRevision: number;
+}
+export declare function parseRoleLaunchSelection(value: unknown): RoleLaunchSelection | undefined;

package/dist/session-launch.d.ts

@@ -1,25 +1,5 @@
-/**
- * session-launch — how a session was launched: provider, model and thinking
- * level, and WHERE each value came from.
- *
- * Wiring-unification Phase E (docs/design/2026-09-23-wiring-unification.md §7,
- * RC5). Before this record the only trace of a session's model was a display
- * string in recent-activity (`buildLegacyModelModeSummaryMetadata`), so nobody
- * could answer "did I pick this model, did the dashboard restore it from last
- * time, did a mesh slot choose it, or is it just the provider default?" — and
- * after a daemon restart not even the value survived.
- *
- * The daemon owns the record (daemon-core `SessionRegistry`); this file holds the
- * shape and the pure readers so daemon-core, web-core, the server and the MCP
- * server all read one definition. It is a dependency-free leaf, like the rest of
- * mesh-shared.
- *
- * ★Server content boundary (CLAUDE.md): the full record rides P2P only. The
- * server path carries exactly two derived fields — `model` (an identifier,
- * passed through {@link sanitizeModelIdentifier}) and `modelSource` (an enum,
- * passed through {@link isModelAxisSource}). Never widen that to the record.
- */
-export declare const MODEL_AXIS_SOURCES: readonly ["user", "remembered", "mesh_slot", "task_override", "provider_default", "unspecified"];
+import { type RoleLaunchSelection } from './role-launch';
+export declare const MODEL_AXIS_SOURCES: readonly ["user", "remembered", "stored_default", "project_default", "mesh_slot", "task_override", "provider_default", "unspecified"];
 export type ModelAxisSource = typeof MODEL_AXIS_SOURCES[number];
 export declare function isModelAxisSource(value: unknown): value is ModelAxisSource;
 /**
@@ -65,6 +45,7 @@ export interface ModelSelection {
     history: ModelSelectionHistoryEntry[];
 }
 export interface SessionLaunchRecord {
+    roleLaunch?: RoleLaunchSelection;
     sessionId: string;
     providerType: string;
     providerVersion?: string;

package/dist/slot-proposal.d.ts

@@ -35,6 +35,13 @@ import { type MeshTaskDifficulty, type NodeCapabilitySlot } from './brain-routin
 export interface CliSlotRecipe {
     /** Optional model to pin on the slot. Best-effort at launch. */
     model?: string;
+    /**
+     * Optional ordered candidate models to prefer when the provider's live
+     * `modelOptions` (from model discovery) is present on `DetectedCliProvider`.
+     * The first candidate present in `modelOptions` wins; falls back to `model`
+     * when `modelOptions` is absent or contains none of the candidates.
+     */
+    modelCandidates?: readonly string[];
     /** Optional thinking level, in the provider's own vocabulary. */
     thinkingLevel?: string;
     /** Difficulty range this slot handles. Empty = general-purpose. */
@@ -76,6 +83,13 @@ export interface DetectedCliProvider {
     displayName?: string;
     /** Detected version, when known. Display only — never affects the mapping. */
     version?: string;
+    /**
+     * Live discovered / resolved `modelOptions` for this provider on the node,
+     * when available on the status catalog. When present and non-empty, recipes
+     * prefer the first matching model from `[recipe.model, ...recipe.modelCandidates]`
+     * that exists in `modelOptions`.
+     */
+    modelOptions?: readonly string[];
 }
 /** One proposed slot plus why it was proposed. */
 export interface ProposedSlotEntry {

package/dist/worker-protocol.d.ts

@@ -30,7 +30,7 @@
  * the protocol contract the marker demarcates.
  */
 import { type MissionBrief } from './mission-brief';
-export declare const WORKER_TOOLS: readonly ["report_completion", "progress_update", "peer_context_pull", "git_status", "git_log", "git_diff"];
+export declare const WORKER_TOOLS: readonly ["report_completion", "progress_update", "peer_context_pull", "git_status", "git_log", "git_diff", "driver_list", "driver_describe", "driver_invoke", "artifact_register"];
 export type WorkerTool = typeof WORKER_TOOLS[number];
 export declare function isWorkerTool(value: unknown): value is WorkerTool;
 /** Stable marker line so a body is never footered twice and tests can find it. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/mesh-shared",
-  "version": "1.0.82-rc.22",
+  "version": "1.0.82-rc.24",
   "description": "ADHDev mesh-shared — pure mesh/git status normalizers shared by daemon-core and web-core",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/assistant-protocol.ts

@@ -11,9 +11,8 @@
  *   - the daemon-only verbs (launch / MCP-only pull / owner actions) that have
  *     no tool.
  *
- * Assistant tools are a separate set from the mesh tools: none of these names
- * belongs in `CANONICAL_MESH_TOOL_NAMES`, and the coordinator/worker MCP modes
- * never publish them.
+ * Assistant-specific tools remain separate from mesh tools. Driver discovery
+ * (list/describe) is shared across all three modes; invoke remains Worker-only.
  */
 
 export const ASSISTANT_TOOLS = [
@@ -33,6 +32,8 @@ export const ASSISTANT_TOOLS = [
     'project_note',
     'launch_defaults',
     'launch_defaults_set',
+    'driver_list',
+    'driver_describe',
 ] as const
 
 export type AssistantTool = typeof ASSISTANT_TOOLS[number]
@@ -46,6 +47,8 @@ export function isAssistantTool(value: unknown): value is AssistantTool {
 /** Daemon verb names (§4.4 table + the five verbs below it). */
 export const ASSISTANT_VERB = {
     // tool verbs
+    driverList: 'driver_list',
+    driverDescribe: 'driver_describe',
     projects: 'assistant_projects',
     environment: 'assistant_environment',
     action: 'assistant_action',
@@ -80,6 +83,8 @@ export type AssistantVerb = typeof ASSISTANT_VERB[keyof typeof ASSISTANT_VERB]
 
 /** The daemon verb each assistant tool calls. */
 export const ASSISTANT_TOOL_VERBS: Readonly<Record<AssistantTool, AssistantVerb>> = {
+    driver_list: ASSISTANT_VERB.driverList,
+    driver_describe: ASSISTANT_VERB.driverDescribe,
     projects: ASSISTANT_VERB.projects,
     environment: ASSISTANT_VERB.environment,
     assistant_action: ASSISTANT_VERB.action,
@@ -123,8 +128,9 @@ export const ASSISTANT_REVIEW_TURN_VERBS: readonly AssistantVerb[] = [
     ASSISTANT_VERB.projectNote,
 ]
 
-/**
- * Env var the daemon sets on the assistant CLI's process (§4.5), read by the
+import { canonicalDaemonId } from './daemon-normalize'
+
+/** Env var the daemon sets on the assistant CLI's process (§4.5), read by the
  * assistant MCP server and forwarded on every verb as
  * `ASSISTANT_SESSION_ID_ARG`. Routing / ownership only — never an auth gate.
  */
@@ -132,3 +138,208 @@ export const ASSISTANT_SESSION_ID_ENV = 'ADHDEV_ASSISTANT_SESSION_ID'
 
 /** Request arg carrying the calling assistant session id. */
 export const ASSISTANT_SESSION_ID_ARG = 'assistantSessionId'
+
+// ─── Remote Assistant Project Follow & Host-Authoritative Grant (rc24) ──────
+
+/**
+ * Conceptual single-assistant slot in the verified account namespace.
+ * Fixed to `'personal'` — one logical assistant per account with one
+ * owner-selected active execution daemon binding per project ACL.
+ */
+export const ASSISTANT_ACCOUNT_SLOT = 'personal' as const
+export type AssistantAccountSlot = typeof ASSISTANT_ACCOUNT_SLOT
+
+/**
+ * Daemon commands for remote project discovery, host ACL grant/revoke, and
+ * assistant-side follow/unfollow. Registered outside `ASSISTANT_VERB` so the
+ * assistant MCP server tool/verb parity table remains untouched.
+ */
+export const ASSISTANT_REMOTE_PROJECT_COMMAND = 'assistant_remote_project' as const
+export const ASSISTANT_REMOTE_PROJECT_CATALOG_COMMAND = 'assistant_remote_project_catalog' as const
+export const ASSISTANT_REMOTE_PROJECT_ACCESS_COMMAND = 'assistant_remote_project_access' as const
+export const ASSISTANT_REMOTE_FOLLOW_COMMAND = 'assistant_remote_follow' as const
+
+/**
+ * Narrow operations a non-roster follower deputy is permitted to invoke on
+ * `assistant_remote_project` when the host's `assistantRemoteAccess` ACL is active.
+ * `note`, `terminal`, and `inventory` remain strictly roster-member-only.
+ */
+export const ASSISTANT_FOLLOWER_ALLOWED_OPS = ['status', 'read', 'poll', 'report', 'send'] as const
+export type AssistantFollowerAllowedOp = typeof ASSISTANT_FOLLOWER_ALLOWED_OPS[number]
+
+const ASSISTANT_FOLLOWER_ALLOWED_OP_SET: ReadonlySet<string> = new Set(ASSISTANT_FOLLOWER_ALLOWED_OPS)
+
+export function isAssistantFollowerAllowedOp(value: unknown): value is AssistantFollowerAllowedOp {
+    return typeof value === 'string' && ASSISTANT_FOLLOWER_ALLOWED_OP_SET.has(value)
+}
+
+/**
+ * Host-authoritative narrow project ACL persisted on the hosting daemon's
+ * `LocalMeshEntry` in `meshes.json`. Revocation increments `grantRevision`
+ * and retains a `'revoked'` tombstone so stale follower caches cannot replay.
+ */
+export interface AssistantRemoteAccessBinding {
+    hostDaemonId: string
+    meshId: string
+    accountSlot: AssistantAccountSlot
+    activeDaemonId: string
+    bindingRevision: number
+    grantRevision: number
+    status: 'active' | 'revoked'
+    allowedOps: readonly AssistantFollowerAllowedOp[]
+    grantedAt: number
+    revokedAt?: number
+}
+
+/**
+ * Durable owner-binding receipt persisted in the assistant daemon's
+ * `assistant.json`. Survives ordinary daemon restarts and session/provider
+ * replacements (`bindSession`), while missing/corrupt/mismatched receipts
+ * fail closed until owner reconciliation.
+ */
+export interface AssistantOwnerBindingReceipt {
+    accountSlot: AssistantAccountSlot
+    daemonId: string
+    bindingRevision: number
+    boundAt: number | string
+}
+
+export type FollowedRemoteProjectState = 'followed' | 'unfollowed' | 'revoked'
+
+export type RemoteAccessState =
+    | 'not_granted'
+    | 'granted_unfollowed'
+    | 'followed'
+    | 'revoked'
+    | 'host_unreachable'
+    | 'binding_mismatch'
+
+/**
+ * Assistant-local followed remote project reference persisted in `assistant.json`.
+ * Never injected into `meshes.json`, `mesh-host-records.json`, `mesh-node-state-push.json`,
+ * or `inlineMeshCache`.
+ */
+export interface FollowedRemoteProjectEntry {
+    /** Canonical key: `${canonicalDaemonId(hostDaemonId)}::${meshId}` */
+    key: string
+    hostDaemonId: string
+    hostLabel?: string
+    meshId: string
+    name: string
+    slug: string
+    sanitizedRepoIdentity: string | null
+    repoIdentity?: string
+    accountSlot: AssistantAccountSlot
+    bindingRevision: number
+    grantRevision: number
+    state: FollowedRemoteProjectState
+    followedAt: number | string
+    updatedAt: number | string
+    unfollowedAt?: number | string
+    revokedAt?: number | string
+    lastCursor?: string | null
+    coordinatorSessionId?: string | null
+    lastErrorCode?: string
+    lastObserved?: {
+        observedAt: number | string
+        coordinatorState?: string
+        coordinatorMissing?: boolean
+        coordinatorPresent?: boolean
+        lastHeadline?: string
+        summary?: string
+    }
+}
+
+/**
+ * Content-free canonical catalog metadata returned by `assistant_remote_project_catalog`
+ * for meshes actually hosted on the queried remote daemon.
+ */
+export interface RemoteProjectCatalogItem {
+    hostDaemonId: string
+    meshId: string
+    name: string
+    sanitizedRepoIdentity: string | null
+    coordinatorState?: 'none' | 'idle' | 'working' | 'waiting' | string
+    capabilities: {
+        status: true
+        read: true
+        poll: true
+        report: true
+        send: true
+        coordinatorPresent?: boolean
+    }
+    observedAt: number | string
+}
+
+/** Build the canonical `(hostDaemonId, meshId)` key used across assistant follow state. */
+export function followedRemoteProjectKey(hostDaemonId: string, meshId: string): string {
+    const canonHost = canonicalDaemonId(hostDaemonId) ?? hostDaemonId.trim()
+    return `${canonHost}::${meshId.trim()}`
+}
+
+/**
+ * Sanitize a repository identity or remote URL into a content-free `host/path`
+ * identifier suitable for remote discovery catalogs. Strips credentials, query
+ * strings, fragments, and `.git` suffixes, and rejects local filesystem paths.
+ */
+export function sanitizeRemoteRepoIdentity(raw: string | null | undefined): string | null {
+    if (typeof raw !== 'string') return null
+    const trimmed = raw.trim()
+    if (!trimmed) return null
+
+    // Reject local filesystem paths (Unix absolute/relative/home, Windows drive/UNC, file:// URLs).
+    if (
+        trimmed.startsWith('/')
+        || trimmed.startsWith('./')
+        || trimmed.startsWith('../')
+        || trimmed.startsWith('~/')
+        || trimmed.startsWith('\\')
+        || /^[a-zA-Z]:[\\/]/.test(trimmed)
+        || /^file:/i.test(trimmed)
+    ) {
+        return null
+    }
+
+    const withoutQuery = trimmed.replace(/[?#].*$/, '').replace(/\/+$/, '')
+    if (!withoutQuery) return null
+
+    let host = ''
+    let repoPath = ''
+
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(withoutQuery)) {
+        try {
+            const url = new URL(withoutQuery)
+            if (url.protocol === 'file:') return null
+            host = url.hostname.toLowerCase()
+            repoPath = decodeURIComponent(url.pathname)
+                .replace(/^\/+|\/+$/g, '')
+                .replace(/\.git$/i, '')
+        } catch {
+            return null
+        }
+    } else {
+        const scpMatch = withoutQuery.match(/^(?:[^@/:]+@)?(\[[^\]]+\]|[^/:]+):(.+)$/)
+        if (scpMatch) {
+            host = scpMatch[1].replace(/^\[|\]$/g, '').toLowerCase()
+            repoPath = scpMatch[2].replace(/^\/+|\/+$/g, '').replace(/\.git$/i, '')
+        } else {
+            const slash = withoutQuery.indexOf('/')
+            if (slash > 0) {
+                const rawHost = withoutQuery.slice(0, slash)
+                const atIdx = rawHost.lastIndexOf('@')
+                host = (atIdx >= 0 ? rawHost.slice(atIdx + 1) : rawHost).toLowerCase()
+                repoPath = withoutQuery.slice(slash + 1).replace(/^\/+|\/+$/g, '').replace(/\.git$/i, '')
+            }
+        }
+    }
+
+    if (!host || !repoPath) return null
+    if (!host.includes('.') && host !== 'localhost') return null
+    if (/[\s@:\\]/.test(host)) return null
+    const segments = repoPath.split('/').filter(Boolean)
+    if (segments.length === 0) return null
+    if (segments.some(seg => seg === '.' || seg === '..' || /[\s@:\\]/.test(seg))) return null
+
+    return `${host}/${segments.join('/')}`.slice(0, 200)
+}
+

package/src/index.ts

@@ -45,3 +45,5 @@ export * from './keyed-doc-delta'
 export * from './provider-approval'
 export * from './provider-question'
 export * from './launch-defaults'
+
+export * from './role-launch';

package/src/launch-defaults.ts

@@ -57,7 +57,7 @@ export interface LaunchDefaultAxis {
 export type LaunchDefaultWarning = 'catalog_unverified' | 'manual_mcp_setup_required';
 export type LaunchDefaultValidationReason =
     | 'invalid_schema' | 'provider_unknown' | 'provider_not_cli' | 'provider_disabled'
-    | 'provider_not_detected' | 'provider_not_eligible' | 'model_unsupported'
+    | 'provider_not_detected' | 'provider_not_eligible' | 'provider_quota_gated' | 'model_unsupported'
     | 'model_provider_mismatch' | 'model_not_offered' | 'thinking_unsupported'
     | 'thinking_not_offered' | 'catalog_unavailable';
 export type LaunchDefaultResolution =

package/src/mesh-tool-names.ts

@@ -65,6 +65,9 @@ export const CANONICAL_MESH_TOOL_NAMES = [
     'mesh_mission_list',
     'mesh_review_inbox',
     'mesh_node_slots',
+    'driver_list',
+    'driver_describe',
+    'artifact_list',
 ] as const;
 
 export type CanonicalMeshToolName = typeof CANONICAL_MESH_TOOL_NAMES[number];

package/src/outbound-message.ts

@@ -321,3 +321,20 @@ export function isOutboundMessage(value: unknown): value is OutboundMessage {
         && isSendPolicy(candidate.policy)
         && typeof candidate.createdAt === 'number'
 }
+
+const PASTED_OPEN_RE = /^\s*<pasted_content(?:\s+id="[^"]*")?\s*>\s*$/
+const PASTED_CLOSE_RE = /^\s*<\/pasted_content(?:\s+id="[^"]*")?\s*>\s*$/
+
+/**
+ * Drop the `<pasted_content>` envelope lines Claude Code wraps around a pasted
+ * input. Only a text that OPENS with the envelope is touched; anything else is
+ * returned unchanged. Shared across daemon transcript merge and web echo/display
+ * normalization so wrapped turns correlate identically.
+ */
+export function unwrapPastedContent(text: string): string {
+    const lines = text.replace(/\r\n?/g, '\n').split('\n')
+    const first = lines.findIndex((line) => line.trim())
+    if (first < 0 || !PASTED_OPEN_RE.test(lines[first])) return text
+    return lines.filter((line) => !PASTED_OPEN_RE.test(line) && !PASTED_CLOSE_RE.test(line)).join('\n')
+}
+

package/src/protocol/daemon-server.ts

@@ -260,8 +260,8 @@ export const DAEMON_P2P_SIGNAL_TYPES = ['p2p_offer', 'p2p_ice'] as const
 export type DaemonP2PSignalType = typeof DAEMON_P2P_SIGNAL_TYPES[number]
 export const isDaemonP2PSignalType = makeTypeGuard(DAEMON_P2P_SIGNAL_TYPES)
 
-export type P2POfferWirePayload = { sdp: string; type: string; peerId: string }
-export type P2PIceWirePayload = { candidate: string; mid: string; peerId: string }
+export type P2POfferWirePayload = { sdp: string; type: string; peerId: string; attemptId?: number; attemptEpoch?: string }
+export type P2PIceWirePayload = { candidate: string; mid: string; peerId: string; attemptId?: number; attemptEpoch?: string }
 
 /**
  * A dashboard-originated signal as relayed to the daemon. `peerId` is stamped
@@ -273,6 +273,8 @@ export type P2PIceWirePayload = { candidate: string; mid: string; peerId: string
 export type RelayedP2PSignalWirePayload = {
     peerId?: string
     daemonId?: string
+    attemptId?: number
+    attemptEpoch?: string
     sharePermission?: string
     shareTargetSessionId?: string
     sdp?: string

package/src/protocol/dashboard-server.ts

@@ -152,6 +152,8 @@ export type SystemAnnouncementWirePayload = {
 export type DashboardP2POfferWirePayload = {
     daemonId: string
     peerId?: string
+    attemptId?: number
+    attemptEpoch?: string
     sdp: string
     type: string
 }
@@ -159,6 +161,8 @@ export type DashboardP2POfferWirePayload = {
 export type DashboardP2PIceWirePayload = {
     daemonId: string
     peerId?: string
+    attemptId?: number
+    attemptEpoch?: string
     candidate: string
     mid?: string
     sdpMid?: string | null
@@ -234,11 +238,13 @@ export const DASHBOARD_P2P_SIGNAL_TYPES = ['p2p_ready', 'p2p_answer', 'p2p_ice']
 export type DashboardP2PSignalType = typeof DASHBOARD_P2P_SIGNAL_TYPES[number]
 export const isDashboardP2PSignalType = makeTypeGuard(DASHBOARD_P2P_SIGNAL_TYPES)
 
-export type DashboardP2PReadyWirePayload = { daemonId: string; peerId: string }
-export type DashboardP2PAnswerWirePayload = { daemonId: string; peerId: string; sdp: string; type: string }
+export type DashboardP2PReadyWirePayload = { daemonId: string; peerId: string; attemptId?: number; attemptEpoch?: string }
+export type DashboardP2PAnswerWirePayload = { daemonId: string; peerId: string; sdp: string; type: string; attemptId?: number; attemptEpoch?: string }
 export type DashboardP2PLocalIceWirePayload = {
     daemonId: string
     peerId: string
+    attemptId?: number
+    attemptEpoch?: string
     candidate: string
     sdpMid: string | null
     sdpMLineIndex: number | null

package/src/role-launch.ts

@@ -0,0 +1,51 @@
+/** Persisted role-launch intent. Restart replays this selection rather than
+ * consulting newer machine defaults; restore preserves its original provenance. */
+import { isLaunchDefaultRole, isLaunchDefaultSource, type LaunchDefaultRole,
+    type LaunchDefaultSelection, type LaunchDefaultAxis, type LaunchDefaultRef } from './launch-defaults';
+export interface RoleLaunchSelection {
+    role: LaunchDefaultRole;
+    selection: LaunchDefaultSelection;
+    applied: Record<keyof LaunchDefaultSelection, LaunchDefaultAxis>;
+    defaultRef?: LaunchDefaultRef;
+    documentRevision: number;
+}
+function record(value: unknown): Record<string, unknown> | undefined {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value as Record<string, unknown> : undefined;
+}
+function ref(value: unknown): LaunchDefaultRef | undefined {
+    const r = record(value);
+    if (!r || !isLaunchDefaultRole(r.role) || (r.scope !== 'global' && r.scope !== 'project')
+        || !Number.isSafeInteger(r.revision) || (r.revision as number) < 1
+        || (r.scope === 'project' && (typeof r.projectId !== 'string' || !r.projectId))) return undefined;
+    return { role: r.role, scope: r.scope, revision: r.revision as number,
+        ...(r.scope === 'project' ? { projectId: r.projectId as string } : {}) };
+}
+function axis(value: unknown): LaunchDefaultAxis | undefined {
+    const a = record(value);
+    if (!a || !isLaunchDefaultSource(a.source) || (a.value !== null && typeof a.value !== 'string')) return undefined;
+    const defaultRef = ref(a.defaultRef);
+    if (a.source === 'stored_default' && defaultRef?.scope !== 'global'
+        || a.source === 'project_default' && defaultRef?.scope !== 'project'
+        || (a.source === 'user' || a.source === 'provider_default') && a.defaultRef !== undefined) return undefined;
+    return { value: a.value as string | null, source: a.source, ...(defaultRef ? { defaultRef } : {}) };
+}
+export function parseRoleLaunchSelection(value: unknown): RoleLaunchSelection | undefined {
+    const r = record(value), s = record(r?.selection), a = record(r?.applied);
+    if (!r || !isLaunchDefaultRole(r.role) || !s || typeof s.provider !== 'string' || !s.provider
+        || !Number.isSafeInteger(r.documentRevision) || (r.documentRevision as number) < 1
+        || (s.model !== undefined && typeof s.model !== 'string')
+        || (s.thinkingLevel !== undefined && typeof s.thinkingLevel !== 'string')) return undefined;
+    const provider = axis(a?.provider), model = axis(a?.model), thinkingLevel = axis(a?.thinkingLevel);
+    if (!provider || !model || !thinkingLevel
+        || [provider, model, thinkingLevel].some(axis => axis.defaultRef && (axis.defaultRef.role !== r.role
+            || axis.defaultRef.scope === 'global' && axis.defaultRef.revision > (r.documentRevision as number)))
+        || provider.value !== s.provider
+        || model.value !== (s.model ?? null) || thinkingLevel.value !== (s.thinkingLevel ?? null)) return undefined;
+    const defaultRef = ref(r.defaultRef);
+    return { role: r.role, selection: { provider: s.provider,
+        ...(typeof s.model === 'string' ? { model: s.model } : {}),
+        ...(typeof s.thinkingLevel === 'string' ? { thinkingLevel: s.thinkingLevel } : {}) },
+        applied: { provider, model, thinkingLevel }, ...(defaultRef ? { defaultRef } : {}),
+        documentRevision: r.documentRevision as number };
+}