@adhdev/mesh-shared 1.0.82-rc.4 → 1.0.82-rc.40

package/src/assistant-protocol.ts

@@ -11,22 +11,35 @@
  *   - 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 = [
     'projects',
+    'environment',
+    'assistant_action',
+    'project_watch',
     'project_status',
     'project_send',
     'project_read',
     'project_add',
+    'project_attach_remote',
     'discover_repos',
     'memory',
+    'memory_search',
     'skill_view',
     'skill_manage',
     'project_note',
+    'launch_defaults',
+    'launch_defaults_set',
+    'driver_list',
+    'driver_describe',
+    'artifact_list',
+    'artifact_read',
+    'decision_answer',
+    'decision_request',
+    'session_control',
 ] as const
 
 export type AssistantTool = typeof ASSISTANT_TOOLS[number]
@@ -40,16 +53,36 @@ 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',
+    watch: 'assistant_project_watch',
+    executionState: 'assistant_execution_state',
+    executionSettings: 'assistant_execution_settings',
     projectStatus: 'assistant_project_status',
     projectSend: 'assistant_project_send',
     projectRead: 'assistant_project_read',
     projectAdd: 'assistant_project_add',
+    projectAttachRemote: 'assistant_project_attach_remote',
     discoverRepos: 'assistant_discover_repos',
     memory: 'assistant_memory',
+    /** Pull-only FTS search over the archive tier (memory design 2026-11-01 §3.4). */
+    memorySearch: 'assistant_memory_search',
     skillView: 'assistant_skill_view',
     skillManage: 'assistant_skill_manage',
     projectNote: 'assistant_project_note',
+    launchDefaults: 'assistant_launch_defaults',
+    launchDefaultsSet: 'assistant_launch_defaults_set',
+    artifactList: 'assistant_artifact_list',
+    artifactRead: 'assistant_artifact_read',
+    /** Owner-decision inbox (structured-missions design 2026-10-28 §6.3): the owner's words recorded as answers. */
+    decisionAnswer: 'assistant_decision_answer',
+    /** Register a plain-text question a coordinator put to the owner as a decision item (§5.2). */
+    decisionRequest: 'assistant_decision_request',
+    /** Stop / restart / switch the provider of a coordinator, worker or the assistant session (handoff design 2026-11-01 §4). */
+    sessionControl: 'assistant_session_control',
     // assistant-side daemon verbs without a tool of the same name
     launch: 'launch_assistant',
     pendingRelays: 'assistant_pending_relays',
@@ -57,22 +90,45 @@ export const ASSISTANT_VERB = {
     stagedResolve: 'assistant_staged_resolve',
     storeAdmin: 'assistant_store_admin',
     importSkills: 'assistant_import_skills',
+    /** Owner skill list (attach/view counts, save proposals, recent skill metrics); reads move no counter. */
+    skillsList: 'assistant_skills_list',
+    /** Owner: what the assistant remembered recently, with undo handles (memory design §3.2). */
+    memoryDigest: 'assistant_memory_digest',
+    /** Owner: reverse one remembered write or one batch (memory design §3.2). Never an assistant tool. */
+    memoryUndo: 'assistant_memory_undo',
+    /** Projects the assistant is following (open relay threads) — list / stop following. */
+    threads: 'assistant_threads',
+    threadClose: 'assistant_thread_close',
 } as const
 
 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,
+    project_watch: ASSISTANT_VERB.watch,
     project_status: ASSISTANT_VERB.projectStatus,
     project_send: ASSISTANT_VERB.projectSend,
     project_read: ASSISTANT_VERB.projectRead,
     project_add: ASSISTANT_VERB.projectAdd,
+    project_attach_remote: ASSISTANT_VERB.projectAttachRemote,
     discover_repos: ASSISTANT_VERB.discoverRepos,
     memory: ASSISTANT_VERB.memory,
+    memory_search: ASSISTANT_VERB.memorySearch,
     skill_view: ASSISTANT_VERB.skillView,
     skill_manage: ASSISTANT_VERB.skillManage,
     project_note: ASSISTANT_VERB.projectNote,
+    launch_defaults: ASSISTANT_VERB.launchDefaults,
+    launch_defaults_set: ASSISTANT_VERB.launchDefaultsSet,
+    artifact_list: ASSISTANT_VERB.artifactList,
+    artifact_read: ASSISTANT_VERB.artifactRead,
+    decision_answer: ASSISTANT_VERB.decisionAnswer,
+    decision_request: ASSISTANT_VERB.decisionRequest,
+    session_control: ASSISTANT_VERB.sessionControl,
 }
 
 /**
@@ -81,25 +137,32 @@ export const ASSISTANT_TOOL_VERBS: Readonly<Record<AssistantTool, AssistantVerb>
  * because they cause effects (a coordinator message or launch, a new
  * project), and MCP clients use readOnlyHint to skip confirmation.
  */
-export const ASSISTANT_WRITE_TOOLS: readonly AssistantTool[] = ['memory', 'skill_manage', 'project_note', 'project_send', 'project_add']
+export const ASSISTANT_WRITE_TOOLS: readonly AssistantTool[] = ['project_watch', 'assistant_action', 'memory', 'skill_manage', 'project_note', 'project_send', 'project_add', 'project_attach_remote', 'launch_defaults_set', 'decision_answer', 'decision_request', 'session_control']
 
 /** Owner-only verbs: never reachable from the assistant's MCP server (no `ipc`). */
 export const ASSISTANT_OWNER_VERBS: readonly AssistantVerb[] = [
+    ASSISTANT_VERB.executionSettings,
     ASSISTANT_VERB.stagedResolve,
     ASSISTANT_VERB.storeAdmin,
     ASSISTANT_VERB.importSkills,
+    ASSISTANT_VERB.skillsList,
+    ASSISTANT_VERB.memoryDigest,
+    ASSISTANT_VERB.memoryUndo,
+    ASSISTANT_VERB.threadClose,
 ]
 
 /** The only assistant verbs accepted while an idle review turn is open (§4.10.7). */
 export const ASSISTANT_REVIEW_TURN_VERBS: readonly AssistantVerb[] = [
     ASSISTANT_VERB.memory,
+    ASSISTANT_VERB.memorySearch,
     ASSISTANT_VERB.skillView,
     ASSISTANT_VERB.skillManage,
     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.
  */
@@ -107,3 +170,236 @@ 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', 'artifact_list', 'artifact_read', 'decision_list', 'decision_answer', 'decision_request'] 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)
+}
+
+/**
+ * Owner-decision ops were added after grants were persisted with an explicit
+ * `allowedOps` list. A grant that already lets the follower read status (list)
+ * or send to the coordinator (answer / register) covers the matching decision op,
+ * so no existing grant needs re-issuing.
+ */
+const DECISION_OP_IMPLIED_BY: Readonly<Record<string, AssistantFollowerAllowedOp>> = {
+    decision_list: 'status',
+    decision_answer: 'send',
+    decision_request: 'send',
+}
+
+export function followerOpPermitted(op: string, allowedOps: readonly AssistantFollowerAllowedOp[]): boolean {
+    if (!isAssistantFollowerAllowedOp(op)) return false
+    if ((allowedOps as readonly string[]).includes(op)) return true
+    const implied = DECISION_OP_IMPLIED_BY[op]
+    return implied !== undefined && allowedOps.includes(implied)
+}
+
+/**
+ * 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[]
+    allowCoordinatorLaunch?: boolean
+    allowArtifactRead?: boolean
+    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
+    allowCoordinatorLaunch?: boolean
+    allowArtifactRead?: boolean
+    state: FollowedRemoteProjectState
+    followedAt: number | string
+    updatedAt: number | string
+    unfollowedAt?: number | string
+    revokedAt?: number | string
+    revokedReason?: 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
+    allowCoordinatorLaunch?: boolean
+    allowArtifactRead?: boolean
+    capabilities: {
+        status: true
+        read: true
+        poll: true
+        report: true
+        send: true
+        coordinatorPresent?: boolean
+        allowCoordinatorLaunch?: boolean
+        allowArtifactRead?: 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/daemon-normalize.ts

@@ -108,13 +108,15 @@ export function isPhantomDaemonEntry(
 export function machineCoreFromDaemonId(id: string | null | undefined): string | undefined {
     const trimmed = readString(id)
     if (!trimmed) return undefined
+    const lower = trimmed.toLowerCase()
     for (const prefix of DAEMON_ID_PREFIXES) {
-        if (trimmed.startsWith(prefix)) {
+        if (lower.startsWith(prefix)) {
             const core = trimmed.slice(prefix.length).trim()
-            return core || undefined
+            if (!core) return undefined
+            return /^mach_/i.test(core) ? `mach_${core.slice(5)}` : core
         }
     }
-    return trimmed
+    return /^mach_/i.test(trimmed) ? `mach_${trimmed.slice(5)}` : trimmed
 }
 
 /**
@@ -144,8 +146,8 @@ export function machineCoreFromDaemonId(id: string | null | undefined): string |
 export function canonicalDaemonId(id: string | null | undefined): string | undefined {
     const core = machineCoreFromDaemonId(id)
     if (!core) return undefined
-    if (!core.startsWith('mach_')) return core
-    return `daemon_${core}`
+    if (!/^mach_/i.test(core)) return core
+    return `daemon_mach_${core.slice(5)}`
 }
 
 /** True when both ids resolve to the same machine core — i.e. they are the same

package/src/decision-push-relay.ts

@@ -0,0 +1,23 @@
+/**
+ * Opt-in "answer a decision from the push notification" relay (mission 4ae3edf2, owner 2026-10-29).
+ *
+ * ★ A deliberate, narrow exception to "no dashboard command relay over server WS" (CLAUDE.md).
+ * With the user's opt-in setting ON and no dashboard window open, the notification's
+ * recommended-option action is POSTed by the service worker to the server, which forwards it to the
+ * owning daemon over the existing daemon WS as ONE fixed command. What crosses the server is exactly
+ * `{ meshId, itemId, optionId }` (+ the single-use answer token that authorizes it) — never the
+ * question, context or free text. Shared so the server's frame and the daemon's ingress cannot drift.
+ */
+
+/** Daemon command the server sends; its only accepted source is {@link DECISION_PUSH_RELAY_SOURCE}. */
+export const DECISION_PUSH_RELAY_COMMAND = 'mission_decision_push_relay_answer'
+
+/** Command source the server stamps on the relayed frame (never settable by REST/API callers). */
+export const DECISION_PUSH_RELAY_SOURCE = 'push_relay'
+
+/** The complete relayed payload — ids only. */
+export type DecisionPushRelayPayload = {
+    meshId: string
+    itemId: string
+    optionId: string
+}

package/src/index.ts

@@ -16,6 +16,7 @@ export * from './git-normalize'
 export * from './session-normalize'
 export * from './node-normalize'
 export * from './node-facts'
+export * from './quota-freshness'
 export * from './workspace-normalize'
 export * from './daemon-normalize'
 export * from './git-summarize'
@@ -40,4 +41,15 @@ export * from './session-launch'
 export * from './turn-ipc'
 export * from './path-ownership'
 export * from './mission-brief'
+export * from './mission-items'
+export * from './mission-git-state'
+export * from './release'
+export * from './decision-push-relay'
 export * from './keyed-doc-delta'
+export * from './provider-approval'
+export * from './provider-question'
+export * from './launch-defaults'
+
+export * from './role-launch';
+export * from './task-source-phase';
+export * from './relay-reprobe'

package/src/keyed-doc-delta.ts

@@ -326,7 +326,15 @@ export function foldKeyedDoc<T extends Record<string, unknown>>(held: T, delta:
         const heldList = heldCollections.get(path)
         if (change?.absent) {
             const [head, tail] = splitPath(path)
-            if (!tail) delete next[head]
+            if (!tail) {
+                delete next[head]
+                continue
+            }
+            const parent = next[head]
+            if (!isRecord(parent) || !(tail in parent)) continue
+            const copy = { ...parent }
+            delete copy[tail]
+            next[head] = copy
             continue
         }
         if (!change && heldList === undefined) continue

package/src/launch-defaults.ts

@@ -0,0 +1,170 @@
+/** Daemon-local launch intent and command wire contract. P2P/local only;
+ * never include this document or its history in cloud status_report.
+ * Publication through mesh-shared's barrel is a later integration step. */
+export const LAUNCH_DEFAULT_ROLES = ['assistant', 'coordinator'] as const;
+export type LaunchDefaultRole = typeof LAUNCH_DEFAULT_ROLES[number];
+export const LAUNCH_DEFAULT_SOURCES = ['user', 'stored_default', 'project_default', 'provider_default'] as const;
+export type LaunchDefaultSource = typeof LAUNCH_DEFAULT_SOURCES[number];
+export const LAUNCH_DEFAULTS_NEXT_LAUNCH_NOTE = 'Applies to the next launch; running sessions are unchanged.';
+export function isLaunchDefaultRole(value: unknown): value is LaunchDefaultRole {
+    return typeof value === 'string' && (LAUNCH_DEFAULT_ROLES as readonly string[]).includes(value);
+}
+export function isLaunchDefaultSource(value: unknown): value is LaunchDefaultSource {
+    return typeof value === 'string' && (LAUNCH_DEFAULT_SOURCES as readonly string[]).includes(value);
+}
+export interface LaunchDefaultSelection {
+    provider: string;
+    /** Omission means pass no model/thinking argument, not inherit another provider. */
+    model?: string;
+    thinkingLevel?: string;
+}
+export type LaunchDefaultToolRestriction = 'enforced' | 'prompt_only';
+export type LaunchDefaultOrigin = 'owner' | 'human' | 'relay' | 'review' | 'review_tainted';
+export interface LaunchDefaultEntry extends LaunchDefaultSelection {
+    revision: number;
+    setBy: 'owner' | 'assistant';
+    setAt: number;
+    /** Ordered quota-failover alternatives (<= 3, distinct providers). Absent = none. */
+    fallback?: LaunchDefaultSelection[];
+}
+export interface LaunchDefaultChange {
+    at: number;
+    role: LaunchDefaultRole;
+    by: 'owner' | 'assistant';
+    origin: LaunchDefaultOrigin;
+    from: LaunchDefaultEntry | null;
+    to: LaunchDefaultEntry | null;
+}
+export interface LaunchDefaultsDocument {
+    version: 1;
+    /** Global document token, including clears; distinct from entry revisions. */
+    revision: number;
+    assistant?: LaunchDefaultEntry;
+    coordinator?: LaunchDefaultEntry;
+    history: LaunchDefaultChange[];
+}
+export interface LaunchDefaultRef {
+    role: LaunchDefaultRole;
+    scope: 'global' | 'project';
+    /** Entry revision for global defaults; host project token for project defaults. */
+    revision: number;
+    projectId?: string;
+}
+export type LaunchDefaultField = keyof LaunchDefaultSelection;
+export interface LaunchDefaultAxis {
+    value: string | null;
+    source: LaunchDefaultSource;
+    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' | '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; applied: Record<LaunchDefaultField, LaunchDefaultAxis>;
+        defaultRef?: LaunchDefaultRef; documentRevision: number; warnings: LaunchDefaultWarning[];
+        toolRestriction: LaunchDefaultToolRestriction }
+    | { ok: false; code: 'launch_default_required' | 'launch_default_unavailable' | 'launch_selection_invalid';
+        role: LaunchDefaultRole; field: LaunchDefaultField; reason: string; source?: LaunchDefaultSource;
+        value?: string | null; defaultRef?: LaunchDefaultRef; candidates?: readonly string[]; hint: string };
+export interface LaunchDefaultsRoleView {
+    stored: LaunchDefaultEntry | null;
+    /** The existing daemon resolver's result, including loud failures. */
+    effective: LaunchDefaultResolution;
+}
+type Target = { role: 'assistant'; project?: never } | { role: 'coordinator'; project?: string };
+export type LaunchDefaultsReadRequest =
+    | ({ action?: 'get' } & (Target | { role?: never; project?: never }))
+    | ({ action: 'check' } & Target & LaunchDefaultSelection);
+/** Mandatory CAS: global document token, or host project token for project writes.
+ * 0 is explicit first setup; clears advance the token and never restore fallback. */
+export type LaunchDefaultsSetRequest = Target & { expectedRevision: number } & (
+    | ({ action: 'set' } & LaunchDefaultSelection)
+    | { action: 'clear'; provider?: never; model?: never; thinkingLevel?: never }
+);
+/** Existing assistant routing envelope; session identity never supplies origin. */
+export type AssistantLaunchDefaultsReadRequest = LaunchDefaultsReadRequest & { assistantSessionId?: string };
+export type AssistantLaunchDefaultsSetRequest = LaunchDefaultsSetRequest & { assistantSessionId?: string };
+export const LAUNCH_DEFAULT_ERROR_CODES = [
+    'invalid_args', 'launch_default_required', 'launch_default_unavailable', 'launch_selection_invalid',
+    'launch_default_invalid', 'revision_conflict', 'store_unavailable', 'store_busy', 'persistence_failed',
+    'project_not_found', 'project_ambiguous', 'project_not_hosted', 'project_storage_unavailable',
+    'staging_unavailable', 'staging_failed', 'review_turn_tool_denied',
+] as const;
+export type LaunchDefaultsErrorCode = typeof LAUNCH_DEFAULT_ERROR_CODES[number];
+export interface LaunchDefaultsError {
+    success: false;
+    code: LaunchDefaultsErrorCode;
+    error: string;
+    reason?: string;
+    role?: LaunchDefaultRole;
+    field?: LaunchDefaultField;
+    source?: LaunchDefaultSource;
+    value?: string | null;
+    defaultRef?: LaunchDefaultRef;
+    candidates?: readonly string[];
+    actualRevision?: number;
+    /** 0 for an absent global document; absent when it cannot be read. */
+    documentRevision?: number;
+    /** A persistence failure can replace intent without confirming durability.
+     * Re-read before retrying; never report applied on committed:true alone. */
+    committed?: boolean;
+}
+export interface LaunchDefaultsReadSuccess {
+    success: true;
+    result: 'get';
+    documentRevision: number;
+    roles: Partial<Record<LaunchDefaultRole, LaunchDefaultsRoleView>>;
+    project?: { projectId: string; revision: number; entry: LaunchDefaultEntry | null };
+}
+export interface LaunchDefaultsCheckSuccess {
+    success: true;
+    result: 'check';
+    role: LaunchDefaultRole;
+    selection: LaunchDefaultSelection;
+    warnings: LaunchDefaultWarning[];
+    toolRestriction: LaunchDefaultToolRestriction;
+    lowersToolLock: boolean;
+}
+export interface LaunchDefaultsApplied {
+    success: true;
+    result: 'applied';
+    role: LaunchDefaultRole;
+    scope: 'global' | 'project';
+    projectId?: string;
+    entry: LaunchDefaultEntry | null;
+    previous: LaunchDefaultEntry | null;
+    /** CAS token returned by the authority that performed the write. */
+    revision: number;
+    warnings: LaunchDefaultWarning[];
+    durable: true;
+    note: string;
+}
+export interface LaunchDefaultsStaged {
+    success: true;
+    result: 'staged';
+    role: LaunchDefaultRole;
+    stagedId: string;
+    previous: LaunchDefaultEntry | null;
+    selection: LaunchDefaultSelection | null;
+    expectedRevision: number;
+    warnings: LaunchDefaultWarning[];
+    note: string;
+}
+/** Existing owner Inbox adapter stores this proposal; it is not another default.
+ * Applying it must revalidate on the host and CAS via the same set handler. */
+export interface LaunchDefaultsProposal {
+    kind: 'launch_defaults';
+    role: LaunchDefaultRole;
+    project?: string;
+    selection: LaunchDefaultSelection | null;
+    previous: LaunchDefaultEntry | null;
+    expectedRevision: number;
+    origin: LaunchDefaultOrigin;
+    callerSessionId?: string;
+}
+export type LaunchDefaultsReadResponse = LaunchDefaultsReadSuccess | LaunchDefaultsCheckSuccess | LaunchDefaultsError;
+export type LaunchDefaultsSetResponse = LaunchDefaultsApplied | LaunchDefaultsStaged | LaunchDefaultsError;
+export type LaunchDefaultsResponse = LaunchDefaultsReadResponse | LaunchDefaultsSetResponse;