Daemon Network Intelligence System

action: enum [list, search, profile]
query: string (required for search) — natural language, e.g., "daemon with LinkedIn access"
daemon_id: string (required for profile by ID)
daemon_name: string (alternative for profile by name)
role_filter: enum [all, agent, daily-driver] (optional, default 'all')
online_only: boolean (optional, default false)

Agent calls daemon_network({ action: "search", query: "daemon with LinkedIn access and dom0" })
    │
    ▼
Tool fetches all daemon profiles from proxy
    POST /api/proxy/daemons/list (device-authenticated)
    │
    ▼
Tool constructs compact JSON payload of all daemon profiles
    Strips verbose fields, keeps: name, role, online, apps, savedLogins, cdp, projects, skills, description
    │
    ▼
Tool calls Haiku via proxy
    POST /api/proxy/llm/anthropic/v1/messages
    Model: claude-haiku-4-5-20251001
    System: "You are a daemon matcher. Given daemon profiles, find the best matches for the query.
             Return JSON: { matches: [{ id, name, reasoning }], noMatch?: string }"
    User: "<profiles>{json}</profiles>\n\nQuery: {query}"
    │
    ▼
Tool parses Haiku response and returns formatted result to main agent

Daemon Network (4 daemons)

24/7 Agents:
  ● atlas [online] — macOS · Engineering
    "Primary CI/CD and code review agent"
    Apps: 12 installed · Logins: github.com, linear.com, slack.com
    CDP: available · Projects: 15 · Skills: 3
    Device: abc123...

  ○ sentinel [offline] — Linux · Infrastructure
    "Server monitoring and deployment agent"
    Apps: 5 installed · Logins: aws.amazon.com, grafana.example.com
    CDP: unavailable · Projects: 8 · Skills: 1
    Device: def456...

Daily Drivers:
  ● jarvis [online] — macOS · Personal
    "Andre's daily driver"
    Apps: 45 installed · Logins: linkedin.com, gmail.com, notion.so
    CDP: available · Projects: 30 · Skills: 5
    Device: ghi789...

  ○ workbox [offline] — Windows · Design
    "Design workstation"
    Device: jkl012...

Search: "daemon that can check LinkedIn"

Matches:
  1. jarvis [daily-driver, online]
     ✓ Has linkedin.com in saved logins
     ✓ CDP available for browser automation
     ⚠ Daily driver — will disrupt user's browser

  2. atlas [agent, online]
     ✗ No LinkedIn login found
     ✓ CDP available
     ℹ Could authenticate if needed

Recommendation: jarvis has LinkedIn access but is a daily driver.
Consider having atlas authenticate to LinkedIn first for unattended automation.

interface DaemonNetworkToolDeps {
  getConfig: () => DaemonConfig;
  getSigningProvider: () => SigningProvider | null;
}

task({ agent: "general", prompt: "..." })                → local subagent (current behavior)
task({ prompt: "...", target_daemon: "abc123" })          → remote execution via Hub

agent: enum [explore, general, browser, plan] (existing — ignored when target_daemon is set)
prompt: string (existing)
target_daemon: string (NEW, optional — device ID of target daemon)
timeout: number (NEW, optional — max wait in seconds for remote tasks, default 300, max 600)

// In task tool execute(), before any remote logic:
if (input.target_daemon) {
  const ctx = getTaskContext();
  const agentMode = ctx?.agentMode;
  if (agentMode === 'skill_builder' || agentMode === 'plan') {
    return 'Cannot delegate to remote daemons in skill_builder or plan mode. These modes require local execution for interactive collaboration with the user.';
  }
}

User Desktop         Source Daemon (daily driver)         Hub         Target Daemon (24/7)
     │                        │                            │                │
     │  (user sends message)  │                            │                │
     │ ─────────────────────▶ │                            │                │
     │                        │  hub:daemon_task_submit     │                │
     │                        │ ──────────────────────────▶ │                │
     │                        │                            │ ─────────────▶ │
     │                        │                            │                │
     │                        │                            │         Create session
     │                        │                            │         (type: 'remote_task')
     │                        │                            │                │
     │                        │                            │         Run Bot0Agent
     │                        │  hub:daemon_task_progress   │                │
     │                        │  (thinking, tool_call, etc) │                │
     │  TaskToolMetadata      │ ◀──────────────────────────│ ◀───────────── │
     │  (live tool display)   │                            │                │
     │ ◀───────────────────── │                            │                │
     │                        │                            │                │
     │                        │  hub:daemon_task_progress   │                │
     │                        │  (permission_request)       │                │
     │  Permission Prompt     │ ◀──────────────────────────│ ◀───────────── │
     │ ◀───────────────────── │                            │                │
     │                        │                            │                │
     │  User: "Allow"         │                            │                │
     │ ─────────────────────▶ │                            │                │
     │                        │  hub:permission_reply       │                │
     │                        │ ──────────────────────────▶ │ ─────────────▶ │
     │                        │                            │                │
     │                        │                            │         (continues executing)
     │                        │                            │                │
     │                        │  hub:daemon_task_result     │                │
     │  <task_result> XML     │ ◀──────────────────────────│ ◀───────────── │
     │ ◀───────────────────── │                            │                │

| 'hub:daemon_task_submit'
| 'hub:daemon_task_progress'
| 'hub:daemon_task_result'

// ─── Daemon → Daemon: Task Submission ────────────────────────────────────────

interface HubDaemonTaskSubmitMessage extends HubMessageBase {
  type: 'hub:daemon_task_submit';
  targetDaemonDeviceId: string;    // Which daemon to execute on
  sourceDaemonDeviceId: string;    // Where to send results/progress back
  prompt: string;
  context?: string;
  workingDirectory?: string;
}

// ─── Daemon → Daemon: Streaming Progress ─────────────────────────────────────
// Mirrors hub:task_progress (desktop↔daemon) but routes daemon-to-daemon.
// Carries the same fields so the source daemon can proxy to its desktop UI.

interface HubDaemonTaskProgressMessage extends HubMessageBase {
  type: 'hub:daemon_task_progress';
  targetDaemonDeviceId: string;    // Source daemon (where to route progress)
  sourceDaemonRequestId: string;   // Original requestId from submit (for correlation)
  taskId: string;
  progressType: 'thinking' | 'assistant' | 'tool_call' | 'tool_result' | 'tool_metadata'
    | 'error' | 'done' | 'permission_request' | 'question_request';
  content?: string;
  tool?: string;
  input?: unknown;
  result?: string;
  error?: string;
  tokenCount?: number;
  inputTokens?: number;
  outputTokens?: number;
  contextTokens?: number;
  metadata?: Record<string, unknown>;
  // Permission request fields (when progressType === 'permission_request')
  permissionRequestId?: string;
  permission?: string;
  permissionPatterns?: string[];
  // Question request fields (when progressType === 'question_request')
  questionRequestId?: string;
  questions?: Array<{
    question: string;
    header: string;
    options: Array<{ label: string; description: string }>;
    multiple?: boolean;
  }>;
}

// ─── Daemon → Daemon: Final Result ───────────────────────────────────────────

interface HubDaemonTaskResultMessage extends HubMessageBase {
  type: 'hub:daemon_task_result';
  targetDaemonDeviceId: string;    // Source daemon (where to route result)
  sourceDaemonRequestId: string;   // Original requestId from submit (for correlation)
  taskId: string;
  success: boolean;
  text?: string;
  error?: string;
  iterations?: number;
  inputTokens?: number;
  outputTokens?: number;
  durationMs?: number;
}

// In Hub.handleMessage() — add to daemon client section:

// New daemon-to-daemon types
case 'hub:daemon_task_submit':
case 'hub:daemon_task_progress':
case 'hub:daemon_task_result':
  this.routeDaemonToDaemon(client, msg);
  break;

// Existing types — extend to accept daemon senders (not just desktop)
// hub:permission_reply and hub:question_reply already route to targetDaemonDeviceId.
// Currently only handled in the desktop client section — add to daemon section too:
case 'hub:permission_reply':
case 'hub:question_reply':
  this.routeDaemonToDaemon(client, msg);
  break;

private routeDaemonToDaemon(source: AuthenticatedClient, msg: HubMessage): void {
  const targetDeviceId = (msg as { targetDaemonDeviceId?: string }).targetDaemonDeviceId;
  if (!targetDeviceId) {
    this.sendError(source.ws, 'Missing targetDaemonDeviceId', msg.requestId);
    return;
  }

  const target = this.daemonClients.get(targetDeviceId);
  if (!target) {
    this.sendError(source.ws, 'Target daemon not connected', msg.requestId);
    return;
  }

  // Cross-user isolation
  if (target.userId !== source.userId) {
    this.sendError(source.ws, 'Access denied', msg.requestId);
    return;
  }

  this.sendMessage(target.ws, msg);
}

// Parallel to taskSourceDesktop — tracks which daemon originated each task
private taskSourceDaemon: Map<string, { deviceId: string; requestId: string }> = new Map();

case 'hub:daemon_task_submit':
  this.handleRemoteTaskSubmit(msg as HubDaemonTaskSubmitMessage);
  break;

private subscribeToEvents(): void {
  this.permissionUnsubscribe = bus.subscribe(PermissionAsked, (event) => {
    const payload = event.properties;

    // Check desktop-originated tasks first (existing)
    for (const [taskId, desktopDeviceId] of this.taskSourceDesktop) {
      const taskState = this.activeTasks.get(taskId);
      if (taskState && !taskState.aborted) {
        // ... existing logic: send hub:task_progress to desktop ...
        return;
      }
    }

    // Check daemon-originated tasks
    for (const [taskId, source] of this.taskSourceDaemon) {
      const taskState = this.activeTasks.get(taskId);
      if (taskState && !taskState.aborted) {
        this.sendDaemonProgress(source.deviceId, source.requestId, taskId, {
          progressType: 'permission_request',
          permissionRequestId: payload.requestId,
          tool: payload.toolName,
          permission: payload.permission,
          permissionPatterns: payload.patterns,
          metadata: payload.metadata,
        });
        return;
      }
    }
  });

  // Same pattern for QuestionAsked → send question_request to source daemon
  this.questionUnsubscribe = bus.subscribe(QuestionAsked, (event) => {
    const payload = event.properties;

    // ... check taskSourceDesktop first (existing) ...

    for (const [taskId, source] of this.taskSourceDaemon) {
      const taskState = this.activeTasks.get(taskId);
      if (taskState && !taskState.aborted) {
        this.sendDaemonProgress(source.deviceId, source.requestId, taskId, {
          progressType: 'question_request',
          questionRequestId: payload.requestId,
          questions: payload.questions,
        });
        return;
      }
    }
  });
}

// ALREADY EXISTS in handleMessage — no changes needed:
case 'hub:permission_reply':
  const permMsg = msg as HubPermissionReplyMessage;
  permissionManager.reply(permMsg.permissionRequestId, permMsg.reply, permMsg.message);
  break;

case 'hub:question_reply':
  const qMsg = msg as HubQuestionReplyMessage;
  questionManager.reply(qMsg.questionRequestId, qMsg.answers);
  break;

private sendDaemonProgress(
  targetDaemonDeviceId: string,
  sourceDaemonRequestId: string,
  taskId: string,
  fields: Partial<HubDaemonTaskProgressMessage>,
): void {
  this.send({
    type: 'hub:daemon_task_progress',
    requestId: generateId(),
    timestamp: Date.now(),
    targetDaemonDeviceId,
    sourceDaemonRequestId,
    taskId,
    progressType: fields.progressType ?? 'assistant',
    content: fields.content,
    tool: fields.tool,
    input: fields.input,
    result: fields.result,
    error: fields.error,
    tokenCount: fields.tokenCount,
    inputTokens: fields.inputTokens,
    outputTokens: fields.outputTokens,
    contextTokens: fields.contextTokens,
    metadata: fields.metadata,
    permissionRequestId: fields.permissionRequestId,
    permission: fields.permission,
    permissionPatterns: fields.permissionPatterns,
    questionRequestId: fields.questionRequestId,
    questions: fields.questions,
  });
}

// In DaemonHubClient:

// Registered by task tool for each active remote task (keyed by requestId)
private remoteTaskHandlers: Map<string, {
  resolve: (result: DaemonTaskResult) => void;
  reject: (error: Error) => void;
  timer: NodeJS.Timeout;
  onProgress: (update: ProgressUpdate) => void;
  onPermission: (requestId: string, tool: string, permission: string, patterns?: string[]) => void;
  onQuestion: (requestId: string, questions: Array<{ question: string; header: string; options: Array<{ label: string; description: string }>; multiple?: boolean }>) => void;
}> = new Map();

// In handleMessage:
case 'hub:daemon_task_progress':
  this.handleRemoteTaskProgress(msg as HubDaemonTaskProgressMessage);
  break;

case 'hub:daemon_task_result':
  this.handleRemoteTaskResult(msg as HubDaemonTaskResultMessage);
  break;

private handleRemoteTaskProgress(msg: HubDaemonTaskProgressMessage): void {
  const handler = this.remoteTaskHandlers.get(msg.sourceDaemonRequestId);
  if (!handler) return;

  if (msg.progressType === 'permission_request') {
    handler.onPermission(
      msg.permissionRequestId!,
      msg.tool ?? '',
      msg.permission ?? '',
      msg.permissionPatterns,
    );
  } else if (msg.progressType === 'question_request') {
    handler.onQuestion(msg.questionRequestId!, msg.questions!);
  } else {
    handler.onProgress({
      type: msg.progressType as ProgressUpdate['type'],
      content: msg.content,
      tool: msg.tool,
      input: msg.input,
      result: msg.result,
      error: msg.error,
      tokenCount: msg.tokenCount,
      inputTokens: msg.inputTokens,
      outputTokens: msg.outputTokens,
      contextTokens: msg.contextTokens,
      metadata: msg.metadata,
    });
  }
}

private handleRemoteTaskResult(msg: HubDaemonTaskResultMessage): void {
  const handler = this.remoteTaskHandlers.get(msg.sourceDaemonRequestId);
  if (handler) {
    clearTimeout(handler.timer);
    this.remoteTaskHandlers.delete(msg.sourceDaemonRequestId);
    handler.resolve(msg as DaemonTaskResult);
  }
}

// In handleMessage, when receiving hub:daemon_status:
case 'hub:daemon_status':
  const statusMsg = msg as HubDaemonStatusMessage;
  if (statusMsg.status === 'offline') {
    // Reject any pending remote tasks targeting the disconnected daemon
    for (const [requestId, handler] of this.remoteTaskHandlers) {
      // Check if this handler's target is the disconnected device
      // (targetDeviceId stored alongside handler at registration time)
      if (handler.targetDeviceId === statusMsg.deviceId) {
        clearTimeout(handler.timer);
        this.remoteTaskHandlers.delete(requestId);
        handler.reject(new Error(`Target daemon disconnected (device: ${statusMsg.deviceId})`));
      }
    }
  }
  break;

async submitRemoteTask(opts: {
  targetDeviceId: string;
  prompt: string;
  context?: string;
  timeoutMs?: number;
  onProgress: (update: ProgressUpdate) => void;
  onPermission: (requestId: string, tool: string, permission: string, patterns?: string[]) => void;
  onQuestion: (requestId: string, questions: Array<{ question: string; header: string; options: Array<{ label: string; description: string }>; multiple?: boolean }>) => void;
}): Promise<DaemonTaskResult> {
  const requestId = generateId();
  const timeoutMs = opts.timeoutMs ?? 300_000;

  return new Promise((resolve, reject) => {
    const timer = setTimeout(() => {
      this.remoteTaskHandlers.delete(requestId);
      reject(new Error(`Remote task timed out after ${timeoutMs / 1000}s`));
    }, timeoutMs);

    this.remoteTaskHandlers.set(requestId, {
      resolve, reject, timer,
      targetDeviceId: opts.targetDeviceId,
      onProgress: opts.onProgress,
      onPermission: opts.onPermission,
      onQuestion: opts.onQuestion,
    });

    this.send({
      type: 'hub:daemon_task_submit',
      requestId,
      targetDaemonDeviceId: opts.targetDeviceId,
      sourceDaemonDeviceId: this.deviceId,
      prompt: opts.prompt,
      context: opts.context,
      timestamp: Date.now(),
    });
  });
}

sendRemotePermissionReply(opts: {
  targetDaemonDeviceId: string;
  permissionRequestId: string;
  reply: 'once' | 'always' | 'reject';
  message?: string;
}): void {
  // Reuse existing hub:permission_reply — same shape, Hub routes to targetDaemonDeviceId
  this.send({
    type: 'hub:permission_reply',
    requestId: generateId(),
    timestamp: Date.now(),
    ...opts,
  });
}

sendRemoteQuestionReply(opts: {
  targetDaemonDeviceId: string;
  questionRequestId: string;
  answers: string[][];
}): void {
  // Reuse existing hub:question_reply — same shape, Hub routes to targetDaemonDeviceId
  this.send({
    type: 'hub:question_reply',
    requestId: generateId(),
    timestamp: Date.now(),
    ...opts,
  });
}

// In task tool execute(), remote path:
if (input.target_daemon) {
  // ── Hard guard: never delegate in skill_builder or plan mode ──
  const ctx = getTaskContext();
  const agentMode = ctx?.agentMode;
  if (agentMode === 'skill_builder' || agentMode === 'plan') {
    return 'Cannot delegate to remote daemons in skill_builder or plan mode. These modes require local execution for interactive collaboration with the user.';
  }

  const hubClient = deps.getHubClient();
  if (!hubClient?.isConnected()) {
    return 'Error: Hub connection required for remote task execution.';
  }

  const parentCtx = getTaskContext();
  const parentEmit = parentCtx?.onToolMetadata;
  let childToolCount = 0;
  const startTime = Date.now();

  // Emit initial metadata for UI (same as local subagent)
  const remoteSessionId = `remote-${generateId()}`;
  parentEmit?.('task', {
    childSessionId: remoteSessionId,
    agentName: `remote:${input.target_daemon.slice(0, 8)}`,
  } as unknown as Record<string, unknown>);

  const result = await hubClient.submitRemoteTask({
    targetDeviceId: input.target_daemon,
    prompt: input.prompt,
    context: input.context,
    timeoutMs: (input.timeout ?? 300) * 1000,

    // ── Streaming: forward to desktop via TaskToolMetadata ──
    onProgress: (update) => {
      if (update.type === 'tool_call') childToolCount++;

      // Forward tool calls and results for live UI display
      // (same pattern as local subagent's onProgress in task.ts:276-288)
      if (update.type === 'tool_call' || update.type === 'tool_result') {
        parentEmit?.('task', {
          childSessionId: remoteSessionId,
          agentName: `remote:${input.target_daemon.slice(0, 8)}`,
          childEvent: update,
        } as unknown as Record<string, unknown>);
      }
    },

    // ── Permissions: route through source daemon's permission system ──
    // IMPORTANT: Permission requestId mapping
    // The target daemon's permissionRequestId (targetReqId) arrives via onPermission.
    // We create a NEW local permission request via the source daemon's permissionManager
    // (which generates its own internal requestId for the desktop UI prompt).
    // When the user approves/denies, the local promise resolves.
    // We then forward the user's decision back using the TARGET daemon's original
    // targetReqId — not the source daemon's internal ID.
    onPermission: async (targetReqId, tool, permission, patterns) => {
      // permissionManager handles: serialization, desktop UI prompt, auto-mode, rules
      // The user sees the permission prompt on their desktop — identical UX to local tools
      const reply = await permissionManager.requestPermission({
        // Generate a fresh local requestId (don't reuse targetReqId to avoid ID collisions)
        toolName: tool,
        permission,
        patterns,
        metadata: { remote: true, targetDaemon: input.target_daemon },
      });

      // Forward user's decision back to the target daemon using the TARGET's original requestId
      hubClient.sendRemotePermissionReply({
        targetDaemonDeviceId: input.target_daemon,
        permissionRequestId: targetReqId,
        reply: reply.decision,
        message: reply.message,
      });
    },

    // ── Questions: same requestId mapping pattern as permissions ──
    onQuestion: async (targetReqId, questions) => {
      // questionManager handles: desktop UI display, user response collection
      const answers = await questionManager.ask({ questions });

      hubClient.sendRemoteQuestionReply({
        targetDaemonDeviceId: input.target_daemon,
        questionRequestId: targetReqId,
        answers,
      });
    },
  });

  const elapsedMs = Date.now() - startTime;

  // Emit done metadata for UI
  parentEmit?.('task', {
    childSessionId: remoteSessionId,
    agentName: `remote:${input.target_daemon.slice(0, 8)}`,
    done: true,
    toolCount: childToolCount,
    elapsedMs,
    inputTokens: result.inputTokens ?? 0,
    outputTokens: result.outputTokens ?? 0,
  } as unknown as Record<string, unknown>);

  // Return same <task_result> XML format
  return {
    output: `<task_result>
<task_id>${remoteSessionId}</task_id>
<agent>remote</agent>
<target_daemon>${input.target_daemon}</target_daemon>
<remote>true</remote>
<description>${input.description}</description>
<tools_used>${childToolCount}</tools_used>
<tokens_in>${result.inputTokens ?? 0}</tokens_in>
<tokens_out>${result.outputTokens ?? 0}</tokens_out>
<elapsed>${(elapsedMs / 1000).toFixed(1)}s</elapsed>
<result>
${result.text ?? result.error ?? 'No response from remote agent'}
</result>
</task_result>`,
    metadata: {
      type: 'task',
      childSessionId: remoteSessionId,
      agentName: 'remote',
      toolCount: childToolCount,
      elapsedMs,
      inputTokens: result.inputTokens ?? 0,
      outputTokens: result.outputTokens ?? 0,
      done: true,
      remote: true,
      targetDaemon: input.target_daemon,
    } as ToolResultMetadata,
  };
} else {
  // ── Local path (existing behavior, unchanged) ──
  // ... spawn child Bot0Agent in-process
}

┌─────────────────────────────────────────────────────┐
│  ▸ task: remote:abc123ab                            │
│    ├─ bash: npm run test                            │
│    ├─ read: src/api/handler.ts                      │
│    ├─ [Permission] bash: rm -rf dist/    [Allow]    │
│    └─ edit_file: src/api/handler.ts                 │
│    ✓ 4 tools · 2,450 in · 890 out · 12.3s          │
└─────────────────────────────────────────────────────┘

interface TaskToolDeps {
  // ... existing deps
  getParentRegistry: () => ToolRegistry;
  getMiddlewares: () => ToolMiddleware[];
  getSessionManager: () => SessionManager | null;
  getSigningProvider: () => SigningProvider | null;
  // NEW — for remote execution
  getHubClient: () => DaemonHubClient | null;
  getConfig: () => DaemonConfig;
}

// In buildSystemPrompt():
const deviceRole = config.deviceRole ?? 'daily-driver';
const daemonId = config.daemonId;

let networkPrompt = '';

if (deviceRole === 'daily-driver') {
  networkPrompt = `
## Daemon Network

You are running on **${name}**, a daily driver machine. This is the user's primary computer — they are actively using it.

You have access to a network of bot0 daemons via the \`daemon_network\` tool and the \`task\` tool's \`target_daemon\` parameter.

**Delegation guidelines:**
- Before running browser automation (dom0), desktop automation (cmd0), or long-running tasks, consider whether a 24/7 agent daemon could handle it instead.
- Use \`daemon_network\` to search for capable daemons, then \`task\` with \`target_daemon\` to delegate.
- This keeps the user's screen, browser, and apps undisturbed.
- If no suitable 24/7 daemon is available, execute locally but warn the user that their screen/browser may be affected.

**When to delegate:**
- dom0 tasks (browser automation) — prefer delegating to a 24/7 agent
- cmd0 tasks (desktop automation) — prefer delegating to a 24/7 agent
- Skill execution that involves dom0/cmd0 — prefer delegating
- Long-running data processing — prefer delegating
- Quick local file operations (read, edit, grep) — execute locally

**NEVER delegate (always run locally):**
- Skill building / skill_builder mode — this is interactive co-design with the user
- Plan mode — the user is collaborating on an implementation plan
- Conversational tasks — questions, discussions, explanations
- The user explicitly asks you to do something on THIS machine
- The task involves files/repos that only exist on this machine
- Quick, non-disruptive operations (file reads, git status, etc.)
`;
} else {
  networkPrompt = `
## Daemon Network

You are running on **${name}**, a dedicated 24/7 agent. Execute tasks directly — this machine is purpose-built for automation.

You can use \`daemon_network\` to discover other daemons and \`task\` with \`target_daemon\` to coordinate multi-daemon work when a task requires capabilities on a different machine (e.g., a specific app, browser account, or codebase).

**NEVER delegate (always run locally):**
- Skill building / skill_builder mode — this is interactive co-design with the user
- Plan mode — the user is collaborating on an implementation plan
- Conversational tasks — questions, discussions, explanations
`;
}

prompt += networkPrompt;

description: text('description'),
category: text('category'),
skills: jsonb('skills').default([]),

interface DaemonConfig {
  // ... existing fields
  daemonId?: string;           // Set during daemon registration
  deviceRole?: 'daily-driver' | 'agent';  // Set during daemon registration
}

1. Schema changes (ctx0_daemons columns)          ← no dependencies
2. Hub protocol (3 new message types)              ← depends on @bot0/core types
3. Hub routing (daemon-to-daemon + existing types) ← depends on protocol
4. daemon_network tool                             ← depends on schema
5. Daemon Hub client (full streaming infra)        ← depends on Hub routing
   - Target: handleRemoteTaskSubmit + sendDaemonProgress + subscribeToEvents extension
   - Source: remoteTaskHandlers + handleRemoteTaskProgress + handleRemoteTaskResult
   - Source: sendRemotePermissionReply (reuses hub:permission_reply) + sendRemoteQuestionReply (reuses hub:question_reply)
   - Source: hub:daemon_status offline → fail-fast handler cleanup
6. task tool remote path (target_daemon)           ← depends on Hub client
   - Hard guard for skill_builder/plan mode
   - Permission requestId mapping (target vs source IDs)
7. System prompt integration                       ← depends on config changes
8. Skill sync mechanism                            ← independent, can parallel with 4-6

engineering: CI/CD, code review, testing
marketing: content, social media, analytics
sales: CRM, outreach, reporting
ops: monitoring, deployment, infrastructure
personal: daily tasks, email, calendar