adhdev 0.9.82-rc.1 → 0.9.82-rc.11

package/dist/cli/index.js

@@ -784,8 +784,14 @@ async function getGitRepoStatus(workspace, options = {}) {
   const includeSubmodules = options.includeSubmodules !== false;
   try {
     const repo = await resolveGitRepository(workspace, options);
-    const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
-    const parsed = parsePorcelainV2Status(statusOutput.stdout);
+    let parsed = await readPorcelainStatus(repo, options);
+    let upstreamProbe = getInitialUpstreamProbe(parsed);
+    if (options.refreshUpstream) {
+      upstreamProbe = await refreshTrackedUpstream(repo, parsed, options);
+      if (upstreamProbe.upstreamStatus === "fresh") {
+        parsed = await readPorcelainStatus(repo, options);
+      }
+    }
     const head = await readHead(repo, options);
     const stashCount = await readStashCount(repo, options);
     let submodules;
@@ -800,6 +806,9 @@ async function getGitRepoStatus(workspace, options = {}) {
       headCommit: head.commit,
       headMessage: head.message,
       upstream: parsed.upstream,
+      upstreamStatus: parsed.upstream ? upstreamProbe.upstreamStatus : "no_upstream",
+      upstreamFetchedAt: upstreamProbe.upstreamFetchedAt,
+      upstreamFetchError: upstreamProbe.upstreamFetchError,
       ahead: parsed.ahead,
       behind: parsed.behind,
       staged: parsed.staged,
@@ -824,6 +833,60 @@ async function getGitRepoStatus(workspace, options = {}) {
     );
   }
 }
+async function readPorcelainStatus(repo, options) {
+  const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
+  return parsePorcelainV2Status(statusOutput.stdout);
+}
+function getInitialUpstreamProbe(parsed) {
+  return {
+    upstreamStatus: parsed.upstream ? "unchecked" : "no_upstream"
+  };
+}
+async function refreshTrackedUpstream(repo, parsed, options) {
+  if (!parsed.upstream || !parsed.branch) {
+    return { upstreamStatus: "no_upstream" };
+  }
+  const remoteName = await readBranchRemote(repo, parsed.branch, options) ?? inferRemoteName(parsed.upstream);
+  if (!remoteName) {
+    return {
+      upstreamStatus: "stale",
+      upstreamFetchError: `Unable to resolve remote for upstream '${parsed.upstream}'`
+    };
+  }
+  try {
+    await runGit(repo, ["fetch", "--quiet", "--prune", "--no-tags", remoteName], options);
+    return {
+      upstreamStatus: "fresh",
+      upstreamFetchedAt: Date.now()
+    };
+  } catch (error48) {
+    return {
+      upstreamStatus: "stale",
+      upstreamFetchError: formatGitError(error48)
+    };
+  }
+}
+async function readBranchRemote(repo, branch, options) {
+  try {
+    const result = await runGit(repo, ["config", "--get", `branch.${branch}.remote`], options);
+    return result.stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function inferRemoteName(upstream) {
+  const [remoteName] = upstream.split("/");
+  return remoteName?.trim() || null;
+}
+function formatGitError(error48) {
+  if (error48 instanceof GitCommandError) {
+    return error48.stderr || error48.message;
+  }
+  if (error48 instanceof Error) {
+    return error48.message;
+  }
+  return String(error48);
+}
 function parsePorcelainV2Status(output) {
   const parsed = {
     branch: null,
@@ -918,6 +981,7 @@ function emptyStatus(workspace, lastCheckedAt, error48) {
     headCommit: null,
     headMessage: null,
     upstream: null,
+    upstreamStatus: "unavailable",
     ahead: 0,
     behind: 0,
     staged: 0,
@@ -1210,6 +1274,9 @@ function createGitCompactSummary(status, diffSummary) {
     isGitRepo: status.isGitRepo,
     repoRoot: status.repoRoot,
     branch: status.branch,
+    upstreamStatus: status.upstreamStatus,
+    upstreamFetchedAt: status.upstreamFetchedAt,
+    upstreamFetchError: status.upstreamFetchError,
     dirty: status.staged > 0 || status.modified > 0 || status.untracked > 0 || status.deleted > 0 || status.renamed > 0 || conflictCount > 0 || changedFiles > 0,
     changedFiles,
     ahead: status.ahead,
@@ -1537,7 +1604,7 @@ function serviceNotImplemented(command) {
 }
 function createDefaultGitCommandServices() {
   return {
-    getStatus: ({ workspace }) => getGitRepoStatus(workspace),
+    getStatus: ({ workspace, refreshUpstream }) => getGitRepoStatus(workspace, { refreshUpstream }),
     getDiffSummary: ({ workspace }) => getGitDiffSummary(workspace),
     getDiffFile: ({ workspace, path: filePath }) => getGitFileDiff(workspace, filePath),
     createSnapshot: ({ workspace, reason, sessionId, turnId }) => defaultSnapshotStore.create({
@@ -1622,7 +1689,7 @@ async function handleGitCommand(command, args, services = defaultGitCommandServi
   switch (command) {
     case "git_status": {
       if (!services.getStatus) return serviceNotImplemented(command);
-      const status = await runService(() => services.getStatus({ workspace }));
+      const status = await runService(() => services.getStatus({ workspace, refreshUpstream: optionalBoolean(args?.refreshUpstream) }));
       return "success" in status ? status : { success: true, status };
     }
     case "git_diff_summary": {
@@ -4279,10 +4346,18 @@ __export(mesh_events_exports, {
   drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
   getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
   handleMeshForwardEvent: () => handleMeshForwardEvent,
+  queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   setupMeshEventForwarding: () => setupMeshEventForwarding,
   triggerMeshQueue: () => triggerMeshQueue,
   tryAssignQueueTask: () => tryAssignQueueTask
 });
+function queuePendingMeshCoordinatorEvent(event) {
+  if (pendingMeshCoordinatorEvents.length >= MAX_PENDING_EVENTS) {
+    return false;
+  }
+  pendingMeshCoordinatorEvents.push(event);
+  return true;
+}
 function drainPendingMeshCoordinatorEvents() {
   return pendingMeshCoordinatorEvents.splice(0);
 }
@@ -4854,17 +4929,18 @@ function injectMeshSystemMessage(components, args) {
     return true;
   });
   if (coordinatorInstances.length === 0) {
-    if (pendingMeshCoordinatorEvents.length < MAX_PENDING_EVENTS) {
-      pendingMeshCoordinatorEvents.push({
-        event: args.event,
-        meshId: args.meshId,
-        nodeLabel: args.nodeLabel,
-        metadataEvent: {
-          ...args.metadataEvent,
-          ...recoveryContext ? { recoveryContext } : {}
-        },
-        queuedAt: Date.now()
-      });
+    if (queuePendingMeshCoordinatorEvent({
+      event: args.event,
+      meshId: args.meshId,
+      nodeLabel: args.nodeLabel,
+      nodeId: args.nodeId || void 0,
+      workspace: readNonEmptyString(args.metadataEvent.workspace),
+      metadataEvent: {
+        ...args.metadataEvent,
+        ...recoveryContext ? { recoveryContext } : {}
+      },
+      queuedAt: Date.now()
+    })) {
       LOG.info("MeshEvents", `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
     }
     return { success: true, forwarded: 0 };
@@ -46381,6 +46457,240 @@ function readProviderPriorityFromPolicy(policy) {
     return true;
   });
 }
+function readObjectRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readStringValue(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return void 0;
+}
+function readNumberValue(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+function readBooleanValue(...values) {
+  for (const value of values) {
+    if (typeof value === "boolean") return value;
+  }
+  return void 0;
+}
+function readGitSubmodules(value) {
+  if (!Array.isArray(value)) return void 0;
+  const submodules = value.map((entry) => {
+    const submodule = readObjectRecord(entry);
+    const path42 = readStringValue(submodule.path);
+    const commit = readStringValue(submodule.commit);
+    const repoPath = readStringValue(submodule.repoPath, submodule.repo_root);
+    if (!path42 || !commit || !repoPath) return null;
+    return {
+      path: path42,
+      commit,
+      repoPath,
+      dirty: readBooleanValue(submodule.dirty) ?? false,
+      outOfSync: readBooleanValue(submodule.outOfSync, submodule.out_of_sync) ?? false,
+      lastCheckedAt: readNumberValue(submodule.lastCheckedAt, submodule.last_checked_at) ?? Date.now(),
+      ...readStringValue(submodule.error) ? { error: readStringValue(submodule.error) } : {}
+    };
+  }).filter((entry) => entry !== null);
+  return submodules.length > 0 ? submodules : void 0;
+}
+function buildCachedInlineMeshGitStatus(node) {
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  const cachedGit = readObjectRecord(cachedStatus.git);
+  if (Object.keys(cachedGit).length) {
+    const conflictFiles2 = Array.isArray(cachedGit.conflictFiles) ? cachedGit.conflictFiles.filter((value) => typeof value === "string") : [];
+    const conflictCount2 = readNumberValue(cachedGit.conflicts) ?? conflictFiles2.length;
+    const hasConflicts2 = readBooleanValue(cachedGit.hasConflicts) ?? conflictCount2 > 0;
+    const isGitRepo2 = readBooleanValue(cachedGit.isGitRepo);
+    if (isGitRepo2 !== void 0) {
+      const submodules2 = readGitSubmodules(cachedGit.submodules);
+      return {
+        workspace: readStringValue(cachedGit.workspace, node?.workspace) || "",
+        repoRoot: readStringValue(cachedGit.repoRoot, node?.repoRoot, node?.workspace) || null,
+        isGitRepo: isGitRepo2,
+        branch: readStringValue(cachedGit.branch) ?? null,
+        headCommit: readStringValue(cachedGit.headCommit) ?? null,
+        headMessage: readStringValue(cachedGit.headMessage) ?? null,
+        upstream: readStringValue(cachedGit.upstream) ?? null,
+        ahead: readNumberValue(cachedGit.ahead) ?? 0,
+        behind: readNumberValue(cachedGit.behind) ?? 0,
+        staged: readNumberValue(cachedGit.staged) ?? 0,
+        modified: readNumberValue(cachedGit.modified) ?? 0,
+        untracked: readNumberValue(cachedGit.untracked) ?? 0,
+        deleted: readNumberValue(cachedGit.deleted) ?? 0,
+        renamed: readNumberValue(cachedGit.renamed) ?? 0,
+        hasConflicts: hasConflicts2,
+        conflictFiles: conflictFiles2,
+        stashCount: readNumberValue(cachedGit.stashCount) ?? 0,
+        lastCheckedAt: readNumberValue(cachedGit.lastCheckedAt) ?? Date.now(),
+        ...submodules2 ? { submodules: submodules2 } : {}
+      };
+    }
+  }
+  const rawGit = readObjectRecord(node?.lastGit ?? node?.last_git);
+  const gitResult = readObjectRecord(rawGit.result);
+  const directStatus = readObjectRecord(rawGit.status);
+  const nestedStatus = readObjectRecord(gitResult.status);
+  const rawProbe = readObjectRecord(node?.lastProbe ?? node?.last_probe);
+  const probeGit = readObjectRecord(rawProbe.git);
+  const probeGitResult = readObjectRecord(probeGit.result);
+  const probeDirectStatus = readObjectRecord(probeGit.status);
+  const probeNestedStatus = readObjectRecord(probeGitResult.status);
+  const status = Object.keys(directStatus).length ? directStatus : Object.keys(nestedStatus).length ? nestedStatus : Object.keys(probeDirectStatus).length ? probeDirectStatus : Object.keys(probeNestedStatus).length ? probeNestedStatus : {};
+  const isGitRepo = readBooleanValue(status.isGitRepo);
+  if (!Object.keys(status).length || isGitRepo === void 0) return void 0;
+  const conflictFiles = Array.isArray(status.conflictFiles) ? status.conflictFiles.filter((value) => typeof value === "string") : [];
+  const conflictCount = readNumberValue(status.conflicts) ?? conflictFiles.length;
+  const hasConflicts = readBooleanValue(status.hasConflicts) ?? conflictCount > 0;
+  const submodules = readGitSubmodules(status.submodules);
+  return {
+    workspace: readStringValue(status.workspace, node?.workspace) || "",
+    repoRoot: readStringValue(status.repoRoot, node?.repoRoot, node?.workspace) || null,
+    isGitRepo,
+    branch: readStringValue(status.branch) ?? null,
+    headCommit: readStringValue(status.headCommit) ?? null,
+    headMessage: readStringValue(status.headMessage) ?? null,
+    upstream: readStringValue(status.upstream) ?? null,
+    ahead: readNumberValue(status.ahead) ?? 0,
+    behind: readNumberValue(status.behind) ?? 0,
+    staged: readNumberValue(status.staged) ?? 0,
+    modified: readNumberValue(status.modified) ?? 0,
+    untracked: readNumberValue(status.untracked) ?? 0,
+    deleted: readNumberValue(status.deleted) ?? 0,
+    renamed: readNumberValue(status.renamed) ?? 0,
+    hasConflicts,
+    conflictFiles,
+    stashCount: readNumberValue(status.stashCount) ?? 0,
+    lastCheckedAt: Date.now(),
+    ...submodules ? { submodules } : {}
+  };
+}
+function hasGitWorktreeChanges(git) {
+  if (!git) return false;
+  return Number(git.staged || 0) + Number(git.modified || 0) + Number(git.untracked || 0) + Number(git.deleted || 0) + Number(git.renamed || 0) > 0;
+}
+function getGitSubmoduleDriftState(git) {
+  const submodules = Array.isArray(git?.submodules) ? git.submodules : [];
+  let dirty = false;
+  let outOfSync = false;
+  for (const entry of submodules) {
+    const submodule = readObjectRecord(entry);
+    if (readBooleanValue(submodule.dirty) === true) dirty = true;
+    if (readBooleanValue(submodule.outOfSync) === true || !!readStringValue(submodule.error)) outOfSync = true;
+  }
+  return { dirty, outOfSync };
+}
+function deriveMeshNodeHealthFromGit(git) {
+  if (!git || readBooleanValue(git.isGitRepo) === false) return "degraded";
+  const branch = readStringValue(git.branch);
+  if (!branch) return "degraded";
+  const submoduleDrift = getGitSubmoduleDriftState(git);
+  if (submoduleDrift.outOfSync) return "degraded";
+  if (submoduleDrift.dirty || hasGitWorktreeChanges(git)) return "dirty";
+  return "online";
+}
+function readCachedInlineMeshActiveSessions(node) {
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  const activeSession = readObjectRecord(cachedStatus.activeSession);
+  const fallbackSession = Object.keys(activeSession).length ? activeSession : readObjectRecord(node?.activeSession ?? node?.active_session);
+  const sessionId = readStringValue(fallbackSession.id, fallbackSession.sessionId, fallbackSession.session_id, node?.activeSessionId, node?.active_session_id, node?.sessionId, node?.session_id);
+  return sessionId ? [sessionId] : [];
+}
+function readCachedInlineMeshActiveSessionDetails(node) {
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  const activeSession = readObjectRecord(cachedStatus.activeSession);
+  const fallbackSession = Object.keys(activeSession).length ? activeSession : readObjectRecord(node?.activeSession ?? node?.active_session);
+  const sessionId = readStringValue(
+    fallbackSession.id,
+    fallbackSession.sessionId,
+    fallbackSession.session_id,
+    node?.activeSessionId,
+    node?.active_session_id,
+    node?.sessionId,
+    node?.session_id
+  );
+  if (!sessionId) return [];
+  return [{
+    sessionId,
+    providerType: readStringValue(
+      fallbackSession.providerType,
+      fallbackSession.provider_type,
+      fallbackSession.cliType,
+      fallbackSession.cli_type,
+      fallbackSession.provider,
+      node?.providerType,
+      node?.provider_type
+    ),
+    state: readStringValue(fallbackSession.status, fallbackSession.state, fallbackSession.lifecycle),
+    lifecycle: readStringValue(fallbackSession.lifecycle),
+    title: readStringValue(fallbackSession.title, fallbackSession.displayName, fallbackSession.display_name) ?? null,
+    workspace: readStringValue(fallbackSession.workspace, node?.workspace) ?? null,
+    lastActivityAt: readStringValue(fallbackSession.lastActivityAt, fallbackSession.last_activity_at) ?? null,
+    recoveryState: readStringValue(fallbackSession.recoveryState, fallbackSession.recovery_state) ?? null,
+    isCached: true
+  }];
+}
+function readLiveMeshSessionState(record2) {
+  return readStringValue(
+    record2?.meta?.sessionStatus,
+    record2?.meta?.status,
+    record2?.meta?.providerStatus,
+    record2?.status,
+    record2?.state,
+    record2?.lifecycle
+  );
+}
+function toIsoTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return new Date(value).toISOString();
+  const stringValue = readStringValue(value);
+  return stringValue || null;
+}
+function summarizeMeshSessionRecord(record2) {
+  return {
+    sessionId: readStringValue(record2?.sessionId) || "unknown",
+    providerType: readStringValue(record2?.providerType),
+    state: readLiveMeshSessionState(record2),
+    lifecycle: readStringValue(record2?.lifecycle),
+    surfaceKind: getSessionHostSurfaceKind(record2),
+    recoveryState: readStringValue(record2?.meta?.runtimeRecoveryState) ?? null,
+    workspace: readStringValue(record2?.workspace) ?? null,
+    title: readStringValue(record2?.displayName, record2?.workspaceLabel) ?? null,
+    lastActivityAt: toIsoTimestamp(record2?.updatedAt ?? record2?.lastActivityAt ?? record2?.last_activity_at),
+    isCached: false
+  };
+}
+function applyCachedInlineMeshNodeStatus(status, node) {
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  const git = buildCachedInlineMeshGitStatus(node);
+  const error48 = readStringValue(cachedStatus.error, node?.error);
+  const health = readStringValue(cachedStatus.health, node?.health);
+  const machineStatus = readStringValue(cachedStatus.machineStatus, node?.machineStatus);
+  const lastSeenAt = toIsoTimestamp(cachedStatus.lastSeenAt ?? cachedStatus.last_seen_at ?? node?.lastSeenAt ?? node?.last_seen_at);
+  const updatedAt = toIsoTimestamp(cachedStatus.updatedAt ?? cachedStatus.updated_at ?? node?.updatedAt ?? node?.updated_at);
+  const activeSessions = readCachedInlineMeshActiveSessions(node);
+  const activeSessionDetails = readCachedInlineMeshActiveSessionDetails(node);
+  if (!git && !error48 && !health && !machineStatus && !lastSeenAt && !updatedAt && activeSessions.length === 0) return false;
+  if (git) status.git = git;
+  if (error48) status.error = error48;
+  if (machineStatus) status.machineStatus = machineStatus;
+  if (lastSeenAt) status.lastSeenAt = lastSeenAt;
+  if (updatedAt) status.updatedAt = updatedAt;
+  if (activeSessions.length > 0) status.activeSessions = activeSessions;
+  if (activeSessionDetails.length > 0) status.activeSessionDetails = activeSessionDetails;
+  if (health) {
+    status.health = health;
+    return true;
+  }
+  if (git) {
+    status.health = deriveMeshNodeHealthFromGit(git);
+    return true;
+  }
+  return activeSessions.length > 0 || !!machineStatus || !!lastSeenAt || !!updatedAt;
+}
 async function resolveProviderTypeFromPriority(args) {
   if (!args.providerPriority.length) {
     return { error: `Node '${args.nodeId}' has no providerPriority policy; pass cliType explicitly or configure node.policy.providerPriority` };
@@ -46769,6 +47079,7 @@ var init_router = __esm({
     init_chat_history();
     init_ide_detector();
     init_cli_detector();
+    init_git_status();
     init_logger();
     init_command_log();
     init_js_yaml();
@@ -46818,7 +47129,12 @@ var init_router = __esm({
         }
         return this.inlineMeshCache.get(meshId);
       }
-      async getMeshForCommand(meshId, inlineMesh) {
+      async getMeshForCommand(meshId, inlineMesh, options) {
+        const preferInline = options?.preferInline === true;
+        if (preferInline) {
+          const cached3 = this.getCachedInlineMesh(meshId, inlineMesh);
+          if (cached3) return { mesh: cached3, inline: true };
+        }
         try {
           const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
           const mesh = getMesh3(meshId);
@@ -48641,7 +48957,7 @@ ${block}`);
             const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
             if (!meshId) return { success: false, error: "meshId required" };
             try {
-              const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+              const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
               const mesh = meshRecord?.mesh;
               if (!mesh) return { success: false, error: "Mesh not found" };
               const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
@@ -48650,84 +48966,102 @@ ${block}`);
               const { readLedgerEntries: readLedgerEntries2, getLedgerSummary: getLedgerSummary2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
               const ledgerEntries = readLedgerEntries2(meshId, { tail: 20 });
               const ledgerSummary = getLedgerSummary2(meshId);
+              const sessionHostRecords = this.deps.sessionHostControl?.listSessions ? await this.deps.sessionHostControl.listSessions().catch(() => []) : [];
+              const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
+              const localMachineId = loadConfig().machineId || "";
+              const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes) ? readStringValue(mesh.nodes[0]?.id, mesh.nodes[0]?.nodeId) : void 0;
+              const refreshedAt = (/* @__PURE__ */ new Date()).toISOString();
               const nodeStatuses = [];
-              for (const node of mesh.nodes || []) {
+              for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
+                const nodeId = String(node.id || node.nodeId || "");
+                const daemonId = readStringValue(node.daemonId);
+                const providerPriority = readProviderPriorityFromPolicy(node.policy);
+                const isSelfNode = Boolean(
+                  nodeId && inlineCoordinatorNodeId && nodeId === inlineCoordinatorNodeId
+                ) || Boolean(
+                  daemonId && (daemonId === localMachineId || daemonId === this.deps.statusInstanceId)
+                ) || Boolean(meshRecord?.inline && nodeIndex === 0);
                 const status = {
-                  nodeId: node.id || node.nodeId,
+                  nodeId,
                   machineLabel: node.machineLabel || node.id || node.nodeId,
                   workspace: node.workspace,
                   repoRoot: node.repoRoot,
                   isLocalWorktree: node.isLocalWorktree,
                   worktreeBranch: node.worktreeBranch,
-                  daemonId: node.daemonId,
+                  daemonId,
                   machineId: node.machineId,
+                  machineStatus: node.machineStatus,
                   health: "unknown",
                   providers: node.providers || [],
-                  activeSessions: []
+                  providerPriority,
+                  activeSessions: [],
+                  activeSessionDetails: [],
+                  launchReady: false
                 };
+                if (isSelfNode) {
+                  status.connection = {
+                    perspective: "selected_coordinator",
+                    source: "mesh_peer_status",
+                    state: "self",
+                    transport: "local",
+                    reported: true,
+                    reason: "Selected coordinator daemon",
+                    lastStateChangeAt: refreshedAt
+                  };
+                } else if (daemonId) {
+                  const connection = this.deps.getMeshPeerConnectionStatus?.(daemonId);
+                  status.connection = connection ?? {
+                    perspective: "selected_coordinator",
+                    source: "not_reported",
+                    state: "unknown",
+                    transport: "unknown",
+                    reported: false,
+                    reason: "No live mesh peer telemetry reported by the selected coordinator yet."
+                  };
+                } else {
+                  status.connection = {
+                    perspective: "selected_coordinator",
+                    source: "not_reported",
+                    state: "unknown",
+                    transport: "unknown",
+                    reported: false,
+                    reason: "Node has no daemon id, so mesh transport cannot be reported from the selected coordinator."
+                  };
+                }
+                const matchedLiveSessionRecords = liveMeshSessions.filter((record2) => this.sessionMatchesMeshNode(record2, node, nodeId));
+                if (matchedLiveSessionRecords.length > 0) {
+                  const sessionIds = matchedLiveSessionRecords.map((record2) => typeof record2?.sessionId === "string" ? record2.sessionId : "").filter(Boolean);
+                  const providerTypes = matchedLiveSessionRecords.map((record2) => readStringValue(record2?.providerType)).filter(Boolean);
+                  status.activeSessions = sessionIds;
+                  status.activeSessionDetails = matchedLiveSessionRecords.map(summarizeMeshSessionRecord);
+                  if (providerTypes.length > 0) {
+                    status.providers = Array.from(/* @__PURE__ */ new Set([...Array.isArray(status.providers) ? status.providers : [], ...providerTypes]));
+                  }
+                }
                 if (node.workspace && typeof node.workspace === "string") {
+                  if (!fs10.existsSync(node.workspace) && applyCachedInlineMeshNodeStatus(status, node)) {
+                    status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
+                    nodeStatuses.push(status);
+                    continue;
+                  }
                   try {
-                    const { execFile: execFile3 } = await import("child_process");
-                    const { promisify: promisify3 } = await import("util");
-                    const execFileAsync3 = promisify3(execFile3);
-                    const runGit2 = async (args2) => {
-                      const result = await execFileAsync3("git", ["-C", node.workspace, ...args2], {
-                        encoding: "utf8",
-                        timeout: 1e4
-                      });
-                      return result.stdout.trim();
-                    };
-                    const branch = await runGit2(["branch", "--show-current"]).catch(() => "");
-                    const porc = await runGit2(["status", "--porcelain"]).catch(() => "");
-                    const headCommit = await runGit2(["rev-parse", "--short", "HEAD"]).catch(() => null);
-                    const headMessage = await runGit2(["log", "-1", "--format=%s"]).catch(() => null);
-                    const upstream = await runGit2(["rev-parse", "--abbrev-ref", "@{upstream}"]).catch(() => null);
-                    const aheadBehind = await runGit2(["rev-list", "--left-right", "--count", "@{upstream}...HEAD"]).catch(() => "");
-                    const stashCount = await runGit2(["stash", "list"]).catch(() => "");
-                    let ahead = 0, behind = 0;
-                    if (aheadBehind) {
-                      const parts = aheadBehind.split(/\s+/);
-                      if (parts.length >= 2) {
-                        behind = parseInt(parts[0], 10) || 0;
-                        ahead = parseInt(parts[1], 10) || 0;
-                      }
-                    }
-                    const dirty = porc.length > 0;
-                    const lines = porc ? porc.split("\n").filter(Boolean) : [];
-                    let staged = 0, modified = 0, untracked = 0, deleted = 0, renamed2 = 0;
-                    for (const line of lines) {
-                      const xy = line.slice(0, 2);
-                      if (xy[0] !== " " && xy[0] !== "?") staged++;
-                      if (xy[1] === "M") modified++;
-                      if (xy[1] === "D") deleted++;
-                      if (xy[0] === "R" || xy[1] === "R") renamed2++;
-                      if (xy === "??") untracked++;
+                    const gitStatus = await getGitRepoStatus(node.workspace, { timeoutMs: 1e4, refreshUpstream: true });
+                    status.git = gitStatus;
+                    if (gitStatus.isGitRepo) {
+                      status.health = deriveMeshNodeHealthFromGit(gitStatus);
+                    } else {
+                      status.health = "degraded";
+                      if (gitStatus.error && !status.error) status.error = gitStatus.error;
                     }
-                    status.git = {
-                      workspace: node.workspace,
-                      repoRoot: node.workspace,
-                      isGitRepo: true,
-                      branch: branch || null,
-                      headCommit,
-                      headMessage,
-                      upstream,
-                      ahead,
-                      behind,
-                      staged,
-                      modified,
-                      untracked,
-                      deleted,
-                      renamed: renamed2,
-                      hasConflicts: false,
-                      conflictFiles: [],
-                      stashCount: stashCount ? stashCount.split("\n").filter(Boolean).length : 0,
-                      lastCheckedAt: Date.now()
-                    };
-                    status.health = branch ? dirty ? "dirty" : "online" : "degraded";
                   } catch {
-                    status.health = "degraded";
+                    if (!applyCachedInlineMeshNodeStatus(status, node)) {
+                      status.health = "degraded";
+                    }
                   }
+                } else {
+                  applyCachedInlineMeshNodeStatus(status, node);
                 }
+                status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
                 nodeStatuses.push(status);
               }
               return {
@@ -48736,6 +49070,7 @@ ${block}`);
                 meshName: mesh.name,
                 repoIdentity: mesh.repoIdentity,
                 defaultBranch: mesh.defaultBranch,
+                refreshedAt: (/* @__PURE__ */ new Date()).toISOString(),
                 nodes: nodeStatuses,
                 queue: { tasks: queue, summary: queueSummary },
                 ledger: { entries: ledgerEntries, summary: ledgerSummary }
@@ -56814,6 +57149,7 @@ async function initDaemonComponents(config2) {
     sessionHostControl: config2.sessionHostControl,
     statusInstanceId: config2.statusInstanceId,
     statusVersion: config2.statusVersion,
+    getMeshPeerConnectionStatus: config2.getMeshPeerConnectionStatus,
     getCdpLogFn: config2.getCdpLogFn || ((ideType) => LOG.forComponent(`CDP:${ideType}`).asLogFn())
   });
   poller = new AgentStreamPoller({
@@ -57115,6 +57451,7 @@ __export(src_exports, {
   prepareSessionChatTailUpdate: () => prepareSessionChatTailUpdate,
   prepareSessionModalUpdate: () => prepareSessionModalUpdate,
   probeCdpPort: () => probeCdpPort,
+  queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   readChatHistory: () => readChatHistory,
   readLedgerEntries: () => readLedgerEntries,
   readLedgerSlice: () => readLedgerSlice,
@@ -97091,11 +97428,30 @@ var init_daemon_mesh_manager = __esm({
       nodeDatachannel = null;
       peers = /* @__PURE__ */ new Map();
       // Map<targetDaemonId, PeerEntry>
+      peerSnapshots = /* @__PURE__ */ new Map();
       pendingRequests = /* @__PURE__ */ new Map();
       commandCallback;
       p2pFailure(message, command, targetDaemonId) {
         return new P2pRelayFailureError(message, { command, targetDaemonId });
       }
+      updatePeerSnapshot(targetDaemonId, state, patch = {}) {
+        const previous = this.peerSnapshots.get(targetDaemonId);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        this.peerSnapshots.set(targetDaemonId, {
+          perspective: "selected_coordinator",
+          source: "mesh_peer_status",
+          reported: true,
+          state,
+          transport: patch.transport ?? previous?.transport ?? "unknown",
+          reason: patch.reason ?? previous?.reason,
+          lastStateChangeAt: now,
+          lastConnectedAt: patch.lastConnectedAt ?? previous?.lastConnectedAt,
+          lastCommandAt: patch.lastCommandAt ?? previous?.lastCommandAt
+        });
+      }
+      getPeerConnectionStatus(targetDaemonId) {
+        return this.peerSnapshots.get(targetDaemonId) ?? null;
+      }
       invalidatePeer(targetDaemonId, reason, options = {}) {
         const peer = this.peers.get(targetDaemonId);
         if (peer?.commandQueue) {
@@ -97110,6 +97466,11 @@ var init_daemon_mesh_manager = __esm({
             pending.reject(this.p2pFailure(reason, pending.command, targetDaemonId));
           }
         }
+        const snapshotState = peer?.state === "closed" ? "closed" : peer?.state === "disconnected" ? "disconnected" : "failed";
+        this.updatePeerSnapshot(targetDaemonId, snapshotState, {
+          reason,
+          transport: peer?.isRelay === true ? "relay" : peer?.isRelay === false ? "direct" : "unknown"
+        });
         if (options.closeResources !== false && peer) {
           try {
             peer.dataChannel?.close?.();
@@ -97142,6 +97503,7 @@ var init_daemon_mesh_manager = __esm({
         "send_chat",
         "read_chat",
         "get_chat_debug_bundle",
+        "get_pending_mesh_events",
         "git_status",
         "git_diff_summary",
         "launch_cli",
@@ -97229,6 +97591,20 @@ var init_daemon_mesh_manager = __esm({
         if (!peer) {
           throw this.p2pFailure("Failed to initiate P2P connection entry", command, targetDaemonId);
         }
+        const lastCommandAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (peer.state === "connected") {
+          this.updatePeerSnapshot(targetDaemonId, "connected", {
+            transport: peer.isRelay === true ? "relay" : peer.isRelay === false ? "direct" : "unknown",
+            lastConnectedAt: this.peerSnapshots.get(targetDaemonId)?.lastConnectedAt,
+            lastCommandAt
+          });
+        } else {
+          this.updatePeerSnapshot(targetDaemonId, "connecting", {
+            transport: peer.isRelay === true ? "relay" : peer.isRelay === false ? "direct" : "unknown",
+            reason: "Waiting for mesh DataChannel to open.",
+            lastCommandAt
+          });
+        }
         return new Promise((resolve23, reject) => {
           const requestId = `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
           const timer = setTimeout(() => {
@@ -97372,6 +97748,9 @@ var init_daemon_mesh_manager = __esm({
           remoteDescriptionSet: false
         };
         this.peers.set(targetDaemonId, entry);
+        this.updatePeerSnapshot(targetDaemonId, "connecting", {
+          reason: isInitiator ? "P2P mesh connection initiated by the selected coordinator." : "Waiting for the remote daemon to finish the mesh DataChannel handshake."
+        });
         pc.onLocalDescription((sdp, type2) => {
           this.serverConn.sendMeshCommand(targetDaemonId, type2 === "offer" ? "mesh_p2p_offer" : "mesh_p2p_answer", { sdp, type: type2 });
         });
@@ -97382,7 +97761,26 @@ var init_daemon_mesh_manager = __esm({
           LOG.info("Mesh", `[Mesh] P2P state with ${targetDaemonId.slice(0, 12)}: ${state}`);
           if (state === "connected") {
             entry.state = "connected";
+            let transport = "unknown";
+            try {
+              const pair = pc.getSelectedCandidatePair?.();
+              if (pair) {
+                const localType = pair.local?.type || "unknown";
+                const remoteType = pair.remote?.type || "unknown";
+                entry.isRelay = localType === "relay" || remoteType === "relay";
+                transport = entry.isRelay ? "relay" : "direct";
+                LOG.info("Mesh", `[Mesh] Candidate pair with ${targetDaemonId.slice(0, 12)}: local=${localType} remote=${remoteType} \u2192 ${transport}`);
+              }
+            } catch {
+              transport = entry.isRelay === true ? "relay" : entry.isRelay === false ? "direct" : "unknown";
+            }
+            this.updatePeerSnapshot(targetDaemonId, "connected", {
+              transport,
+              reason: transport === "relay" ? "Connected over TURN relay." : transport === "direct" ? "Connected directly peer-to-peer." : "Connected, but selected candidate pair details are unavailable.",
+              lastConnectedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
           } else if (state === "failed" || state === "closed" || state === "disconnected") {
+            entry.state = state;
             this.invalidatePeer(targetDaemonId, `P2P state changed to ${state}`, { rejectPending: true, closeResources: false });
           }
         });
@@ -97400,6 +97798,11 @@ var init_daemon_mesh_manager = __esm({
         dc.onOpen(() => {
           LOG.info("Mesh", `[Mesh] DataChannel OPEN with ${targetDaemonId.slice(0, 12)}`);
           entry.state = "connected";
+          this.updatePeerSnapshot(targetDaemonId, "connected", {
+            transport: entry.isRelay === true ? "relay" : entry.isRelay === false ? "direct" : "unknown",
+            reason: entry.isRelay === true ? "Connected over TURN relay." : entry.isRelay === false ? "Connected directly peer-to-peer." : "DataChannel open; transport details not reported yet.",
+            lastConnectedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
           if (entry.commandQueue) {
             const queue = entry.commandQueue;
             entry.commandQueue = [];
@@ -97679,6 +98082,7 @@ var init_adhdev_daemon = __esm({
     "use strict";
     init_server_connection();
     init_src();
+    init_mesh_events();
     init_daemon_p2p2();
     init_screenshot_controller();
     init_session_host();
@@ -97695,7 +98099,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.1" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.11" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -98219,6 +98623,7 @@ ${err?.stack || ""}`);
               if (!this.meshManager) throw new Error("Mesh manager not initialized");
               return this.meshManager.sendCommand(daemonId, command, args);
             },
+            getMeshPeerConnectionStatus: (daemonId) => this.meshManager?.getPeerConnectionStatus(daemonId) ?? null,
             onStatusChange: () => {
               this.invalidateHotChatSnapshotCache();
               this.statusReporter?.onStatusChange();
@@ -98611,6 +99016,21 @@ ${err?.stack || ""}`);
           await this.meshManager.sendCommand(coordinatorDaemonId, "mesh_forward_event", payload);
           LOG.info("MeshEvents", `Relayed ${payload.event} for mesh ${meshId} to coordinator daemon ${coordinatorDaemonId.slice(0, 12)}\u2026`);
         } catch (error48) {
+          queuePendingMeshCoordinatorEvent({
+            event: payload.event,
+            meshId,
+            nodeLabel: payload.nodeId ? `Node '${payload.nodeId}'` : payload.workspace ? `Agent at ${payload.workspace}` : "Remote agent",
+            nodeId: payload.nodeId || void 0,
+            workspace: payload.workspace || void 0,
+            metadataEvent: {
+              targetSessionId: payload.targetSessionId,
+              providerType: payload.providerType,
+              providerSessionId: payload.providerSessionId,
+              finalSummary: payload.finalSummary,
+              workspace: payload.workspace
+            },
+            queuedAt: Date.now()
+          });
           LOG.warn("MeshEvents", `Failed to relay ${payload.event} for mesh ${meshId}: ${error48?.message || error48}`);
         }
       }
@@ -99517,6 +99937,420 @@ var init_runtime_target_trace = __esm({
   }
 });
 
+// src/cli/service-commands.ts
+var service_commands_exports = {};
+__export(service_commands_exports, {
+  buildPlist: () => buildPlist,
+  installAutoStartServiceForCurrentProcess: () => installAutoStartServiceForCurrentProcess,
+  isAutoStartServiceInstalled: () => isAutoStartServiceInstalled,
+  registerServiceCommands: () => registerServiceCommands
+});
+function getDarwinPlistPath() {
+  return import_node_path5.default.join(import_node_os4.default.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+}
+function getWindowsStartupDir() {
+  const appData = process.env.APPDATA || import_node_path5.default.join(import_node_os4.default.homedir(), "AppData", "Roaming");
+  return import_node_path5.default.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+}
+function getWindowsVbsPath() {
+  return import_node_path5.default.join(getWindowsStartupDir(), "adhdev-daemon.vbs");
+}
+function resolveCliPath() {
+  return import_node_fs4.default.realpathSync(process.argv[1]);
+}
+function ensureDir(dir) {
+  if (!import_node_fs4.default.existsSync(dir)) import_node_fs4.default.mkdirSync(dir, { recursive: true });
+}
+async function fetchHealth() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), DEFAULT_LOCAL_DAEMON_HEALTH_TIMEOUT_MS2);
+  try {
+    const res = await fetch(`http://127.0.0.1:${DEFAULT_DAEMON_PORT}/health`, { signal: controller.signal });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function getProcessInfo(pid) {
+  try {
+    if (process.platform === "win32") {
+      const out = (0, import_node_child_process4.execSync)(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, { encoding: "utf-8" });
+      const match = out.match(/"(\d[\d,]+)\sK"/);
+      const memKB = match ? parseInt(match[1].replace(/,/g, ""), 10) : 0;
+      return { uptime: "-", memMB: Math.round(memKB / 1024) };
+    } else {
+      const out = (0, import_node_child_process4.execSync)(`ps -o etime=,rss= -p ${pid}`, { encoding: "utf-8" }).trim();
+      const parts = out.split(/\s+/);
+      const etime = parts[0] || "-";
+      const rssKB = parseInt(parts[1] || "0", 10);
+      return { uptime: formatElapsed(etime), memMB: Math.round(rssKB / 1024) };
+    }
+  } catch {
+    return null;
+  }
+}
+function formatElapsed(etime) {
+  const parts = etime.replace("-", ":").split(":").map(Number);
+  if (parts.length === 4) return `${parts[0]}d ${parts[1]}h ${parts[2]}m`;
+  if (parts.length === 3) return `${parts[0]}h ${parts[1]}m`;
+  if (parts.length === 2) return `${parts[0]}m ${parts[1]}s`;
+  return etime;
+}
+function rotateLogIfNeeded(logPath) {
+  try {
+    if (!import_node_fs4.default.existsSync(logPath)) return;
+    const stat5 = import_node_fs4.default.statSync(logPath);
+    if (stat5.size > MAX_LOG_SIZE2) {
+      const rotated = logPath + ".old";
+      if (import_node_fs4.default.existsSync(rotated)) import_node_fs4.default.unlinkSync(rotated);
+      import_node_fs4.default.renameSync(logPath, rotated);
+      import_node_fs4.default.writeFileSync(logPath, `[log rotated at ${(/* @__PURE__ */ new Date()).toISOString()}]
+`, "utf-8");
+    }
+  } catch {
+  }
+}
+function rotateLogs() {
+  rotateLogIfNeeded(LOG_OUT);
+  rotateLogIfNeeded(LOG_ERR);
+}
+function normalizeLaunchdPathEntry(entry) {
+  const trimmed = String(entry || "").trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("~")) {
+    return import_node_path5.default.join(import_node_os4.default.homedir(), trimmed.slice(1));
+  }
+  return import_node_path5.default.isAbsolute(trimmed) ? trimmed : null;
+}
+function buildLaunchdPath(nodeExe, currentPath = process.env.PATH || "") {
+  const brewPrefix = import_node_fs4.default.existsSync("/opt/homebrew/bin") ? "/opt/homebrew/bin" : "/usr/local/bin";
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addEntry = (value) => {
+    if (!value) return;
+    const normalized = normalizeLaunchdPathEntry(value);
+    if (!normalized || seen.has(normalized)) return;
+    seen.add(normalized);
+    entries.push(normalized);
+  };
+  addEntry(import_node_path5.default.dirname(nodeExe));
+  for (const entry of String(currentPath || "").split(import_node_path5.default.delimiter)) {
+    addEntry(entry);
+  }
+  for (const entry of [brewPrefix, "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"]) {
+    addEntry(entry);
+  }
+  return entries.join(":");
+}
+function buildPlist(nodeExe, cliExe, currentPath = process.env.PATH || "") {
+  const pathValue = buildLaunchdPath(nodeExe, currentPath);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${LAUNCHD_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodeExe}</string>
+        <string>${cliExe}</string>
+        <string>daemon</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <dict>
+        <key>SuccessfulExit</key>
+        <false/>
+    </dict>
+    <key>ThrottleInterval</key>
+    <integer>30</integer>
+    <key>StandardOutPath</key>
+    <string>${LOG_OUT}</string>
+    <key>StandardErrorPath</key>
+    <string>${LOG_ERR}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${pathValue}</string>
+    </dict>
+</dict>
+</plist>`;
+}
+function installDarwin(nodeExe, cliExe) {
+  const plistPath = getDarwinPlistPath();
+  ensureDir(ADHDEV_DIR);
+  ensureDir(import_node_path5.default.dirname(plistPath));
+  import_node_fs4.default.writeFileSync(plistPath, buildPlist(nodeExe, cliExe), "utf-8");
+  console.log(source_default.gray(`  Plist: ${plistPath}`));
+  try {
+    (0, import_node_child_process4.execSync)(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore" });
+  } catch {
+  }
+  try {
+    (0, import_node_child_process4.execSync)(`launchctl load -w "${plistPath}"`, { stdio: "ignore" });
+    console.log(source_default.green("\n  \u2713 Registered as LaunchAgent \u2014 daemon will start on login."));
+    console.log(source_default.gray(`  Logs: ~/.adhdev/daemon-launchd.{out,err}`));
+  } catch (e) {
+    console.log(source_default.red(`
+  \u2717 launchctl load failed: ${e.message}`));
+  }
+}
+function uninstallDarwin() {
+  const plistPath = getDarwinPlistPath();
+  if (!import_node_fs4.default.existsSync(plistPath)) {
+    console.log(source_default.yellow("\n  \u26A0 Service is not installed."));
+    return;
+  }
+  try {
+    (0, import_node_child_process4.execSync)(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore" });
+  } catch {
+  }
+  import_node_fs4.default.unlinkSync(plistPath);
+  console.log(source_default.green("\n  \u2713 Removed LaunchAgent. Daemon will no longer auto-start."));
+}
+function isInstalledDarwin() {
+  return import_node_fs4.default.existsSync(getDarwinPlistPath());
+}
+function buildVbs(nodeExe, cliExe) {
+  const logFile = import_node_path5.default.join(ADHDEV_DIR, "daemon-service.log").replace(/\\/g, "\\\\");
+  const escapedNodeExe = nodeExe.replace(/\\/g, "\\\\");
+  const escapedCliExe = cliExe.replace(/\\/g, "\\\\");
+  return `' ADHDev Daemon Auto-Start (generated by adhdev service install)
+Set WshShell = CreateObject("WScript.Shell")
+WshShell.Run "cmd.exe /c """"${escapedNodeExe}"""" """"${escapedCliExe}"""" daemon >> """"${logFile}"""" 2>&1", 0, False
+`;
+}
+function installWindows(nodeExe, cliExe) {
+  const vbsPath = getWindowsVbsPath();
+  ensureDir(ADHDEV_DIR);
+  ensureDir(import_node_path5.default.dirname(vbsPath));
+  import_node_fs4.default.writeFileSync(vbsPath, buildVbs(nodeExe, cliExe), "utf-8");
+  console.log(source_default.gray(`  Startup script: ${vbsPath}`));
+  console.log(source_default.green("\n  \u2713 Registered in Startup folder \u2014 daemon will start on login (hidden)."));
+  console.log(source_default.gray(`  Logs: ${import_node_path5.default.join(ADHDEV_DIR, "daemon-service.log")}`));
+  console.log(source_default.gray("  To start now without rebooting, run: adhdev daemon"));
+}
+function uninstallWindows() {
+  const vbsPath = getWindowsVbsPath();
+  if (!import_node_fs4.default.existsSync(vbsPath)) {
+    console.log(source_default.yellow("\n  \u26A0 Service is not installed."));
+    return;
+  }
+  import_node_fs4.default.unlinkSync(vbsPath);
+  console.log(source_default.green("\n  \u2713 Removed Startup script. Daemon will no longer auto-start."));
+  console.log(source_default.gray("  Note: a currently running daemon is not affected. Stop with: adhdev daemon:stop"));
+}
+function isInstalledWindows() {
+  return import_node_fs4.default.existsSync(getWindowsVbsPath());
+}
+function isAutoStartServiceInstalled(platform12 = import_node_os4.default.platform()) {
+  if (platform12 === "darwin") return isInstalledDarwin();
+  if (platform12 === "win32") return isInstalledWindows();
+  return false;
+}
+function installAutoStartServiceForCurrentProcess(platform12 = import_node_os4.default.platform()) {
+  const nodeExe = process.execPath;
+  const cliExe = resolveCliPath();
+  if (platform12 === "darwin") {
+    installDarwin(nodeExe, cliExe);
+    return true;
+  }
+  if (platform12 === "win32") {
+    installWindows(nodeExe, cliExe);
+    return true;
+  }
+  return false;
+}
+function registerServiceCommands(program2) {
+  const svc = program2.command("service").description("\u{1F50C} Manage ADHDev as an OS background auto-start service");
+  svc.command("install").description("Register ADHDev daemon to start automatically on login").action(async () => {
+    console.log(source_default.bold("\n  \u{1F680} Installing ADHDev Background Service"));
+    const platform12 = import_node_os4.default.platform();
+    const nodeExe = process.execPath;
+    const cliExe = resolveCliPath();
+    console.log(source_default.gray(`  Node:     ${nodeExe}`));
+    console.log(source_default.gray(`  CLI:      ${cliExe}`));
+    console.log(source_default.gray(`  Platform: ${platform12}`));
+    if (!installAutoStartServiceForCurrentProcess(platform12)) {
+      console.log(source_default.yellow("\n  \u26A0 Auto-start service install is not supported on this platform."));
+      console.log(source_default.gray("  On Linux, create a systemd user unit manually:"));
+      console.log(source_default.gray("    ~/.config/systemd/user/adhdev-daemon.service"));
+    }
+    console.log();
+  });
+  svc.command("uninstall").description("Remove the OS background service").action(async () => {
+    console.log(source_default.bold("\n  \u{1F5D1}\uFE0F  Removing ADHDev Background Service"));
+    const platform12 = import_node_os4.default.platform();
+    if (platform12 === "darwin") {
+      uninstallDarwin();
+    } else if (platform12 === "win32") {
+      uninstallWindows();
+    } else {
+      console.log(source_default.yellow("\n  \u26A0 Not supported on this platform."));
+    }
+    console.log();
+  });
+  svc.command("status").description("Show service installation state and live daemon health").action(async () => {
+    const platform12 = import_node_os4.default.platform();
+    const installed = isAutoStartServiceInstalled(platform12);
+    if (installed) {
+      console.log(source_default.green("\n  \u2713 Service is installed."));
+      if (platform12 === "darwin") console.log(source_default.gray(`  Plist:  ${getDarwinPlistPath()}`));
+      else console.log(source_default.gray(`  Script: ${getWindowsVbsPath()}`));
+    } else {
+      console.log(source_default.gray("\n  \u2717 Service is not installed. Run: adhdev service install"));
+    }
+    const health = await fetchHealth();
+    if (health?.ok && health.pid) {
+      const info = getProcessInfo(health.pid);
+      if (info) {
+        console.log(source_default.green(`  \u2713 Daemon running \u2014 PID ${health.pid}, uptime ${info.uptime}, ${info.memMB} MB`));
+      } else {
+        console.log(source_default.green(`  \u2713 Daemon running \u2014 PID ${health.pid}`));
+      }
+    } else {
+      console.log(source_default.yellow("  \u2717 Daemon is not running."));
+    }
+    const outSize = import_node_fs4.default.existsSync(LOG_OUT) ? import_node_fs4.default.statSync(LOG_OUT).size : 0;
+    const errSize = import_node_fs4.default.existsSync(LOG_ERR) ? import_node_fs4.default.statSync(LOG_ERR).size : 0;
+    if (outSize > 0 || errSize > 0) {
+      console.log(source_default.gray(`  Logs:   stdout ${formatBytes(outSize)}, stderr ${formatBytes(errSize)}`));
+    }
+    console.log();
+  });
+  svc.command("logs").description("View daemon service logs").option("--err", "Show stderr log instead of stdout").option("--clear", "Truncate all log files").option("-n, --lines <count>", "Number of lines to show", "30").action(async (options) => {
+    if (options.clear) {
+      for (const f of [LOG_OUT, LOG_ERR]) {
+        if (import_node_fs4.default.existsSync(f)) import_node_fs4.default.writeFileSync(f, "", "utf-8");
+      }
+      console.log(source_default.green("\n  \u2713 Logs cleared.\n"));
+      return;
+    }
+    const logFile = options.err ? LOG_ERR : LOG_OUT;
+    if (!import_node_fs4.default.existsSync(logFile)) {
+      console.log(source_default.gray(`
+  No log file found: ${logFile}
+`));
+      return;
+    }
+    const lines = parseInt(options.lines, 10) || 30;
+    console.log(source_default.gray(`
+  \u2500\u2500 ${options.err ? "stderr" : "stdout"}: ${logFile} (last ${lines} lines) \u2500\u2500
+`));
+    const content = import_node_fs4.default.readFileSync(logFile, "utf-8");
+    const allLines = content.split("\n");
+    const lastLines = allLines.slice(-lines).join("\n");
+    if (lastLines.trim()) console.log(lastLines);
+    console.log(source_default.gray("\n  (watching for new output, Ctrl+C to stop)\n"));
+    let offset = Buffer.byteLength(content, "utf-8");
+    const watcher = import_node_fs4.default.watchFile(logFile, { interval: 500 }, () => {
+      try {
+        const stat5 = import_node_fs4.default.statSync(logFile);
+        if (stat5.size > offset) {
+          const fd = import_node_fs4.default.openSync(logFile, "r");
+          const buf = Buffer.alloc(stat5.size - offset);
+          import_node_fs4.default.readSync(fd, buf, 0, buf.length, offset);
+          import_node_fs4.default.closeSync(fd);
+          process.stdout.write(buf.toString("utf-8"));
+          offset = stat5.size;
+        } else if (stat5.size < offset) {
+          offset = 0;
+        }
+      } catch {
+      }
+    });
+    const cleanup = () => {
+      import_node_fs4.default.unwatchFile(logFile);
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  });
+  svc.command("restart").description("Restart the daemon process (service will auto-relaunch)").action(async () => {
+    const platform12 = import_node_os4.default.platform();
+    const installed = isAutoStartServiceInstalled(platform12);
+    if (!installed) {
+      console.log(source_default.yellow("\n  \u26A0 Service is not installed. Use `adhdev daemon:restart` for manual restart."));
+      console.log(source_default.gray("  Or install the service first: adhdev service install\n"));
+      return;
+    }
+    rotateLogs();
+    if (platform12 === "darwin") {
+      console.log(source_default.cyan("\n  Refreshing LaunchAgent definition and reloading service..."));
+      installAutoStartServiceForCurrentProcess(platform12);
+      console.log();
+      return;
+    }
+    const health = await fetchHealth();
+    if (!health?.pid) {
+      console.log(source_default.yellow("\n  \u26A0 Daemon is not currently running."));
+      console.log(source_default.gray("  Start with: adhdev daemon\n"));
+      return;
+    }
+    console.log(source_default.cyan(`
+  Stopping daemon (PID ${health.pid})...`));
+    try {
+      process.kill(health.pid, "SIGTERM");
+    } catch {
+      console.log(source_default.yellow("  Could not send SIGTERM. Process may have already exited."));
+    }
+    await new Promise((r) => setTimeout(r, 2e3));
+    if (platform12 === "win32") {
+      const vbsPath = getWindowsVbsPath();
+      if (import_node_fs4.default.existsSync(vbsPath)) {
+        try {
+          (0, import_node_child_process4.execSync)(`wscript.exe "${vbsPath}"`, { stdio: "ignore", windowsHide: true });
+        } catch {
+        }
+      }
+    }
+    let restarted = false;
+    for (let i = 0; i < 8; i++) {
+      await new Promise((r) => setTimeout(r, 1e3));
+      const newHealth = await fetchHealth();
+      if (newHealth?.ok && newHealth.pid !== health.pid) {
+        restarted = true;
+        const info = getProcessInfo(newHealth.pid);
+        console.log(source_default.green(`  \u2713 Daemon restarted \u2014 new PID ${newHealth.pid}${info ? `, ${info.memMB} MB` : ""}`));
+        break;
+      }
+    }
+    if (!restarted) {
+      console.log(source_default.yellow("  \u26A0 Daemon did not restart within 10s."));
+      console.log(source_default.gray("  Check: adhdev service logs --err"));
+    }
+    console.log();
+  });
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+var import_node_fs4, import_node_path5, import_node_os4, import_node_child_process4, DEFAULT_LOCAL_DAEMON_HEALTH_TIMEOUT_MS2, LAUNCHD_LABEL, ADHDEV_DIR, LOG_OUT, LOG_ERR, MAX_LOG_SIZE2;
+var init_service_commands = __esm({
+  "src/cli/service-commands.ts"() {
+    "use strict";
+    import_node_fs4 = __toESM(require("fs"));
+    import_node_path5 = __toESM(require("path"));
+    import_node_os4 = __toESM(require("os"));
+    import_node_child_process4 = require("child_process");
+    init_source();
+    init_src();
+    DEFAULT_LOCAL_DAEMON_HEALTH_TIMEOUT_MS2 = 1500;
+    LAUNCHD_LABEL = "dev.adhf.daemon";
+    ADHDEV_DIR = import_node_path5.default.join(import_node_os4.default.homedir(), ".adhdev");
+    LOG_OUT = import_node_path5.default.join(ADHDEV_DIR, "daemon-launchd.out");
+    LOG_ERR = import_node_path5.default.join(ADHDEV_DIR, "daemon-launchd.err");
+    MAX_LOG_SIZE2 = 10 * 1024 * 1024;
+  }
+});
+
 // ../../oss/packages/web-core/src/constants/supported.ts
 var supported_exports = {};
 __export(supported_exports, {
@@ -101490,7 +102324,7 @@ function formatDebugTraceEntryLine(entry) {
 }
 
 // src/cli/daemon-commands.ts
-var DEFAULT_LOCAL_DAEMON_HEALTH_TIMEOUT_MS2 = 1500;
+var DEFAULT_LOCAL_DAEMON_HEALTH_TIMEOUT_MS3 = 1500;
 var DEFAULT_TRACE_FOLLOW_INTERVAL_MS = 1500;
 var DEFAULT_DAEMON_PORT_TEXT = String(DEFAULT_DAEMON_PORT);
 var DEV_SERVER_PORT2 = 19280;
@@ -101518,6 +102352,15 @@ async function resolveConfiguredUpdateChannel() {
 function releaseChannelLabel(channel) {
   return `${channel} (${CHANNEL_NPM_TAG3[channel]})`;
 }
+function buildDaemonRestartCommandArgv(options = {}) {
+  const cliPath = options.cliPath || process.argv[1];
+  const daemonPort = options.daemonPort || DEFAULT_DAEMON_PORT_TEXT;
+  const platform12 = options.platform || process.platform;
+  if (platform12 === "darwin" && options.serviceInstalled) {
+    return [cliPath, "service", "install"];
+  }
+  return [cliPath, "daemon", "-p", daemonPort];
+}
 async function persistReleaseChannel(channel) {
   const { updateConfig: updateConfig2 } = await Promise.resolve().then(() => (init_src(), src_exports));
   updateConfig2({ updateChannel: channel, serverUrl: CHANNEL_SERVER_URL3[channel] });
@@ -101528,7 +102371,7 @@ function hideCommand(command) {
 }
 async function fetchLocalDaemonHealth(port) {
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), DEFAULT_LOCAL_DAEMON_HEALTH_TIMEOUT_MS2);
+  const timer = setTimeout(() => controller.abort(), DEFAULT_LOCAL_DAEMON_HEALTH_TIMEOUT_MS3);
   try {
     const res = await fetch(`http://127.0.0.1:${port}/health`, { signal: controller.signal });
     if (!res.ok) return null;
@@ -101894,6 +102737,9 @@ async function runDaemonUpgrade(options, pkgVersion3) {
     } else {
       console.log(source_default.cyan(`
   Upgrading v${currentVersion} \u2192 v${latest}...`));
+      const { isAutoStartServiceInstalled: isAutoStartServiceInstalled2 } = await Promise.resolve().then(() => (init_service_commands(), service_commands_exports));
+      const serviceInstalled = isAutoStartServiceInstalled2();
+      const shouldRefreshInstalledService = options.restart !== false && process.platform === "darwin" && serviceInstalled;
       const daemonWasRunning = options.restart !== false && isDaemonRunning2();
       if (daemonWasRunning) {
         stopDaemon2();
@@ -101905,10 +102751,22 @@ async function runDaemonUpgrade(options, pkgVersion3) {
         packageName: "adhdev",
         targetVersion: latest,
         parentPid: process.pid,
-        restartArgv: daemonWasRunning ? [process.argv[1], "daemon", "-p", DEFAULT_DAEMON_PORT_TEXT] : [],
+        restartArgv: shouldRefreshInstalledService ? buildDaemonRestartCommandArgv({
+          cliPath: process.argv[1],
+          daemonPort: DEFAULT_DAEMON_PORT_TEXT,
+          platform: process.platform,
+          serviceInstalled
+        }) : daemonWasRunning ? buildDaemonRestartCommandArgv({
+          cliPath: process.argv[1],
+          daemonPort: DEFAULT_DAEMON_PORT_TEXT,
+          platform: process.platform,
+          serviceInstalled
+        }) : [],
         cwd: process.cwd()
       });
-      if (daemonWasRunning) {
+      if (shouldRefreshInstalledService) {
+        console.log(source_default.cyan("  Upgrading and refreshing background service in background..."));
+      } else if (daemonWasRunning) {
         console.log(source_default.cyan("  Upgrading and restarting daemon in background..."));
       } else {
         console.log(source_default.cyan("  Upgrading in background..."));
@@ -101920,29 +102778,44 @@ async function runDaemonUpgrade(options, pkgVersion3) {
       return;
     }
   }
-  if (options.restart !== false && isDaemonRunning2()) {
-    console.log(source_default.yellow("\n  Restarting daemon..."));
-    stopDaemon2();
-    await new Promise((r) => setTimeout(r, 2e3));
-    stopManagedSessionHostProcess2();
-    await new Promise((r) => setTimeout(r, 500));
-    const child = spawn7(process.execPath, [process.argv[1], "daemon", "-p", DEFAULT_DAEMON_PORT_TEXT], {
-      detached: true,
-      stdio: "ignore",
-      windowsHide: true,
-      env: { ...process.env }
-    });
-    child.unref();
-    await new Promise((r) => setTimeout(r, 3e3));
+  if (options.restart !== false) {
+    const { installAutoStartServiceForCurrentProcess: installAutoStartServiceForCurrentProcess2, isAutoStartServiceInstalled: isAutoStartServiceInstalled2 } = await Promise.resolve().then(() => (init_service_commands(), service_commands_exports));
+    const serviceInstalled = isAutoStartServiceInstalled2();
+    if (process.platform === "darwin" && serviceInstalled) {
+      console.log(source_default.yellow("\n  Refreshing LaunchAgent definition..."));
+      installAutoStartServiceForCurrentProcess2(process.platform);
+      console.log();
+      return;
+    }
     if (isDaemonRunning2()) {
-      console.log(source_default.green(`  \u2713 Daemon restarted with new version
+      console.log(source_default.yellow("\n  Restarting daemon..."));
+      stopDaemon2();
+      await new Promise((r) => setTimeout(r, 2e3));
+      stopManagedSessionHostProcess2();
+      await new Promise((r) => setTimeout(r, 500));
+      const child = spawn7(process.execPath, buildDaemonRestartCommandArgv({
+        cliPath: process.argv[1],
+        daemonPort: DEFAULT_DAEMON_PORT_TEXT,
+        platform: process.platform,
+        serviceInstalled
+      }), {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        env: { ...process.env }
+      });
+      child.unref();
+      await new Promise((r) => setTimeout(r, 3e3));
+      if (isDaemonRunning2()) {
+        console.log(source_default.green(`  \u2713 Daemon restarted with new version
 `));
-    } else {
-      console.log(source_default.yellow(`  \u26A0 Daemon not detected. Start manually: adhdev daemon
+      } else {
+        console.log(source_default.yellow(`  \u26A0 Daemon not detected. Start manually: adhdev daemon
 `));
+      }
+    } else {
+      console.log(source_default.gray("\n  Daemon was not running. Start with: adhdev daemon\n"));
     }
-  } else if (options.restart !== false) {
-    console.log(source_default.gray("\n  Daemon was not running. Start with: adhdev daemon\n"));
   } else {
     console.log(source_default.green("\n  \u2713 Upgrade complete (daemon not restarted)\n"));
   }
@@ -102113,7 +102986,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
       }
       try {
         const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), DEFAULT_LOCAL_DAEMON_HEALTH_TIMEOUT_MS2);
+        const timer = setTimeout(() => controller.abort(), DEFAULT_LOCAL_DAEMON_HEALTH_TIMEOUT_MS3);
         const res = await fetch(`${DEV_SERVER_BASE_URL}/api/status`, { signal: controller.signal });
         clearTimeout(timer);
         if (res.ok) {
@@ -102660,373 +103533,8 @@ function buildDoctorAdvice(input) {
   return advice;
 }
 
-// src/cli/service-commands.ts
-var import_node_fs4 = __toESM(require("fs"));
-var import_node_path5 = __toESM(require("path"));
-var import_node_os4 = __toESM(require("os"));
-var import_node_child_process4 = require("child_process");
-init_source();
-init_src();
-var DEFAULT_LOCAL_DAEMON_HEALTH_TIMEOUT_MS3 = 1500;
-var LAUNCHD_LABEL = "dev.adhf.daemon";
-var ADHDEV_DIR = import_node_path5.default.join(import_node_os4.default.homedir(), ".adhdev");
-var LOG_OUT = import_node_path5.default.join(ADHDEV_DIR, "daemon-launchd.out");
-var LOG_ERR = import_node_path5.default.join(ADHDEV_DIR, "daemon-launchd.err");
-var MAX_LOG_SIZE2 = 10 * 1024 * 1024;
-function getDarwinPlistPath() {
-  return import_node_path5.default.join(import_node_os4.default.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-}
-function getWindowsStartupDir() {
-  const appData = process.env.APPDATA || import_node_path5.default.join(import_node_os4.default.homedir(), "AppData", "Roaming");
-  return import_node_path5.default.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
-}
-function getWindowsVbsPath() {
-  return import_node_path5.default.join(getWindowsStartupDir(), "adhdev-daemon.vbs");
-}
-function resolveCliPath() {
-  return import_node_fs4.default.realpathSync(process.argv[1]);
-}
-function ensureDir(dir) {
-  if (!import_node_fs4.default.existsSync(dir)) import_node_fs4.default.mkdirSync(dir, { recursive: true });
-}
-async function fetchHealth() {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), DEFAULT_LOCAL_DAEMON_HEALTH_TIMEOUT_MS3);
-  try {
-    const res = await fetch(`http://127.0.0.1:${DEFAULT_DAEMON_PORT}/health`, { signal: controller.signal });
-    if (!res.ok) return null;
-    return await res.json();
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-function getProcessInfo(pid) {
-  try {
-    if (process.platform === "win32") {
-      const out = (0, import_node_child_process4.execSync)(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, { encoding: "utf-8" });
-      const match = out.match(/"(\d[\d,]+)\sK"/);
-      const memKB = match ? parseInt(match[1].replace(/,/g, ""), 10) : 0;
-      return { uptime: "-", memMB: Math.round(memKB / 1024) };
-    } else {
-      const out = (0, import_node_child_process4.execSync)(`ps -o etime=,rss= -p ${pid}`, { encoding: "utf-8" }).trim();
-      const parts = out.split(/\s+/);
-      const etime = parts[0] || "-";
-      const rssKB = parseInt(parts[1] || "0", 10);
-      return { uptime: formatElapsed(etime), memMB: Math.round(rssKB / 1024) };
-    }
-  } catch {
-    return null;
-  }
-}
-function formatElapsed(etime) {
-  const parts = etime.replace("-", ":").split(":").map(Number);
-  if (parts.length === 4) return `${parts[0]}d ${parts[1]}h ${parts[2]}m`;
-  if (parts.length === 3) return `${parts[0]}h ${parts[1]}m`;
-  if (parts.length === 2) return `${parts[0]}m ${parts[1]}s`;
-  return etime;
-}
-function rotateLogIfNeeded(logPath) {
-  try {
-    if (!import_node_fs4.default.existsSync(logPath)) return;
-    const stat5 = import_node_fs4.default.statSync(logPath);
-    if (stat5.size > MAX_LOG_SIZE2) {
-      const rotated = logPath + ".old";
-      if (import_node_fs4.default.existsSync(rotated)) import_node_fs4.default.unlinkSync(rotated);
-      import_node_fs4.default.renameSync(logPath, rotated);
-      import_node_fs4.default.writeFileSync(logPath, `[log rotated at ${(/* @__PURE__ */ new Date()).toISOString()}]
-`, "utf-8");
-    }
-  } catch {
-  }
-}
-function rotateLogs() {
-  rotateLogIfNeeded(LOG_OUT);
-  rotateLogIfNeeded(LOG_ERR);
-}
-function buildPlist(nodeExe, cliExe) {
-  const brewPrefix = import_node_fs4.default.existsSync("/opt/homebrew/bin") ? "/opt/homebrew/bin" : "/usr/local/bin";
-  const nodeDir = import_node_path5.default.dirname(nodeExe);
-  const pathEntries = /* @__PURE__ */ new Set([nodeDir, brewPrefix, "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"]);
-  const pathValue = Array.from(pathEntries).join(":");
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>${LAUNCHD_LABEL}</string>
-    <key>ProgramArguments</key>
-    <array>
-        <string>${nodeExe}</string>
-        <string>${cliExe}</string>
-        <string>daemon</string>
-    </array>
-    <key>RunAtLoad</key>
-    <true/>
-    <key>KeepAlive</key>
-    <dict>
-        <key>SuccessfulExit</key>
-        <false/>
-    </dict>
-    <key>ThrottleInterval</key>
-    <integer>30</integer>
-    <key>StandardOutPath</key>
-    <string>${LOG_OUT}</string>
-    <key>StandardErrorPath</key>
-    <string>${LOG_ERR}</string>
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>PATH</key>
-        <string>${pathValue}</string>
-    </dict>
-</dict>
-</plist>`;
-}
-function installDarwin(nodeExe, cliExe) {
-  const plistPath = getDarwinPlistPath();
-  ensureDir(ADHDEV_DIR);
-  ensureDir(import_node_path5.default.dirname(plistPath));
-  import_node_fs4.default.writeFileSync(plistPath, buildPlist(nodeExe, cliExe), "utf-8");
-  console.log(source_default.gray(`  Plist: ${plistPath}`));
-  try {
-    (0, import_node_child_process4.execSync)(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore" });
-  } catch {
-  }
-  try {
-    (0, import_node_child_process4.execSync)(`launchctl load -w "${plistPath}"`, { stdio: "ignore" });
-    console.log(source_default.green("\n  \u2713 Registered as LaunchAgent \u2014 daemon will start on login."));
-    console.log(source_default.gray(`  Logs: ~/.adhdev/daemon-launchd.{out,err}`));
-  } catch (e) {
-    console.log(source_default.red(`
-  \u2717 launchctl load failed: ${e.message}`));
-  }
-}
-function uninstallDarwin() {
-  const plistPath = getDarwinPlistPath();
-  if (!import_node_fs4.default.existsSync(plistPath)) {
-    console.log(source_default.yellow("\n  \u26A0 Service is not installed."));
-    return;
-  }
-  try {
-    (0, import_node_child_process4.execSync)(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore" });
-  } catch {
-  }
-  import_node_fs4.default.unlinkSync(plistPath);
-  console.log(source_default.green("\n  \u2713 Removed LaunchAgent. Daemon will no longer auto-start."));
-}
-function isInstalledDarwin() {
-  return import_node_fs4.default.existsSync(getDarwinPlistPath());
-}
-function buildVbs(nodeExe, cliExe) {
-  const logFile = import_node_path5.default.join(ADHDEV_DIR, "daemon-service.log").replace(/\\/g, "\\\\");
-  const escapedNodeExe = nodeExe.replace(/\\/g, "\\\\");
-  const escapedCliExe = cliExe.replace(/\\/g, "\\\\");
-  return `' ADHDev Daemon Auto-Start (generated by adhdev service install)
-Set WshShell = CreateObject("WScript.Shell")
-WshShell.Run "cmd.exe /c """"${escapedNodeExe}"""" """"${escapedCliExe}"""" daemon >> """"${logFile}"""" 2>&1", 0, False
-`;
-}
-function installWindows(nodeExe, cliExe) {
-  const vbsPath = getWindowsVbsPath();
-  ensureDir(ADHDEV_DIR);
-  ensureDir(import_node_path5.default.dirname(vbsPath));
-  import_node_fs4.default.writeFileSync(vbsPath, buildVbs(nodeExe, cliExe), "utf-8");
-  console.log(source_default.gray(`  Startup script: ${vbsPath}`));
-  console.log(source_default.green("\n  \u2713 Registered in Startup folder \u2014 daemon will start on login (hidden)."));
-  console.log(source_default.gray(`  Logs: ${import_node_path5.default.join(ADHDEV_DIR, "daemon-service.log")}`));
-  console.log(source_default.gray("  To start now without rebooting, run: adhdev daemon"));
-}
-function uninstallWindows() {
-  const vbsPath = getWindowsVbsPath();
-  if (!import_node_fs4.default.existsSync(vbsPath)) {
-    console.log(source_default.yellow("\n  \u26A0 Service is not installed."));
-    return;
-  }
-  import_node_fs4.default.unlinkSync(vbsPath);
-  console.log(source_default.green("\n  \u2713 Removed Startup script. Daemon will no longer auto-start."));
-  console.log(source_default.gray("  Note: a currently running daemon is not affected. Stop with: adhdev daemon:stop"));
-}
-function isInstalledWindows() {
-  return import_node_fs4.default.existsSync(getWindowsVbsPath());
-}
-function registerServiceCommands(program2) {
-  const svc = program2.command("service").description("\u{1F50C} Manage ADHDev as an OS background auto-start service");
-  svc.command("install").description("Register ADHDev daemon to start automatically on login").action(async () => {
-    console.log(source_default.bold("\n  \u{1F680} Installing ADHDev Background Service"));
-    const platform12 = import_node_os4.default.platform();
-    const nodeExe = process.execPath;
-    const cliExe = resolveCliPath();
-    console.log(source_default.gray(`  Node:     ${nodeExe}`));
-    console.log(source_default.gray(`  CLI:      ${cliExe}`));
-    console.log(source_default.gray(`  Platform: ${platform12}`));
-    if (platform12 === "darwin") {
-      installDarwin(nodeExe, cliExe);
-    } else if (platform12 === "win32") {
-      installWindows(nodeExe, cliExe);
-    } else {
-      console.log(source_default.yellow("\n  \u26A0 Auto-start service install is not supported on this platform."));
-      console.log(source_default.gray("  On Linux, create a systemd user unit manually:"));
-      console.log(source_default.gray("    ~/.config/systemd/user/adhdev-daemon.service"));
-    }
-    console.log();
-  });
-  svc.command("uninstall").description("Remove the OS background service").action(async () => {
-    console.log(source_default.bold("\n  \u{1F5D1}\uFE0F  Removing ADHDev Background Service"));
-    const platform12 = import_node_os4.default.platform();
-    if (platform12 === "darwin") {
-      uninstallDarwin();
-    } else if (platform12 === "win32") {
-      uninstallWindows();
-    } else {
-      console.log(source_default.yellow("\n  \u26A0 Not supported on this platform."));
-    }
-    console.log();
-  });
-  svc.command("status").description("Show service installation state and live daemon health").action(async () => {
-    const platform12 = import_node_os4.default.platform();
-    const installed = platform12 === "darwin" ? isInstalledDarwin() : platform12 === "win32" ? isInstalledWindows() : false;
-    if (installed) {
-      console.log(source_default.green("\n  \u2713 Service is installed."));
-      if (platform12 === "darwin") console.log(source_default.gray(`  Plist:  ${getDarwinPlistPath()}`));
-      else console.log(source_default.gray(`  Script: ${getWindowsVbsPath()}`));
-    } else {
-      console.log(source_default.gray("\n  \u2717 Service is not installed. Run: adhdev service install"));
-    }
-    const health = await fetchHealth();
-    if (health?.ok && health.pid) {
-      const info = getProcessInfo(health.pid);
-      if (info) {
-        console.log(source_default.green(`  \u2713 Daemon running \u2014 PID ${health.pid}, uptime ${info.uptime}, ${info.memMB} MB`));
-      } else {
-        console.log(source_default.green(`  \u2713 Daemon running \u2014 PID ${health.pid}`));
-      }
-    } else {
-      console.log(source_default.yellow("  \u2717 Daemon is not running."));
-    }
-    const outSize = import_node_fs4.default.existsSync(LOG_OUT) ? import_node_fs4.default.statSync(LOG_OUT).size : 0;
-    const errSize = import_node_fs4.default.existsSync(LOG_ERR) ? import_node_fs4.default.statSync(LOG_ERR).size : 0;
-    if (outSize > 0 || errSize > 0) {
-      console.log(source_default.gray(`  Logs:   stdout ${formatBytes(outSize)}, stderr ${formatBytes(errSize)}`));
-    }
-    console.log();
-  });
-  svc.command("logs").description("View daemon service logs").option("--err", "Show stderr log instead of stdout").option("--clear", "Truncate all log files").option("-n, --lines <count>", "Number of lines to show", "30").action(async (options) => {
-    if (options.clear) {
-      for (const f of [LOG_OUT, LOG_ERR]) {
-        if (import_node_fs4.default.existsSync(f)) import_node_fs4.default.writeFileSync(f, "", "utf-8");
-      }
-      console.log(source_default.green("\n  \u2713 Logs cleared.\n"));
-      return;
-    }
-    const logFile = options.err ? LOG_ERR : LOG_OUT;
-    if (!import_node_fs4.default.existsSync(logFile)) {
-      console.log(source_default.gray(`
-  No log file found: ${logFile}
-`));
-      return;
-    }
-    const lines = parseInt(options.lines, 10) || 30;
-    console.log(source_default.gray(`
-  \u2500\u2500 ${options.err ? "stderr" : "stdout"}: ${logFile} (last ${lines} lines) \u2500\u2500
-`));
-    const content = import_node_fs4.default.readFileSync(logFile, "utf-8");
-    const allLines = content.split("\n");
-    const lastLines = allLines.slice(-lines).join("\n");
-    if (lastLines.trim()) console.log(lastLines);
-    console.log(source_default.gray("\n  (watching for new output, Ctrl+C to stop)\n"));
-    let offset = Buffer.byteLength(content, "utf-8");
-    const watcher = import_node_fs4.default.watchFile(logFile, { interval: 500 }, () => {
-      try {
-        const stat5 = import_node_fs4.default.statSync(logFile);
-        if (stat5.size > offset) {
-          const fd = import_node_fs4.default.openSync(logFile, "r");
-          const buf = Buffer.alloc(stat5.size - offset);
-          import_node_fs4.default.readSync(fd, buf, 0, buf.length, offset);
-          import_node_fs4.default.closeSync(fd);
-          process.stdout.write(buf.toString("utf-8"));
-          offset = stat5.size;
-        } else if (stat5.size < offset) {
-          offset = 0;
-        }
-      } catch {
-      }
-    });
-    const cleanup = () => {
-      import_node_fs4.default.unwatchFile(logFile);
-      process.exit(0);
-    };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-  });
-  svc.command("restart").description("Restart the daemon process (service will auto-relaunch)").action(async () => {
-    const platform12 = import_node_os4.default.platform();
-    const installed = platform12 === "darwin" ? isInstalledDarwin() : platform12 === "win32" ? isInstalledWindows() : false;
-    if (!installed) {
-      console.log(source_default.yellow("\n  \u26A0 Service is not installed. Use `adhdev daemon:restart` for manual restart."));
-      console.log(source_default.gray("  Or install the service first: adhdev service install\n"));
-      return;
-    }
-    rotateLogs();
-    const health = await fetchHealth();
-    if (!health?.pid) {
-      console.log(source_default.yellow("\n  \u26A0 Daemon is not currently running."));
-      if (platform12 === "darwin") {
-        console.log(source_default.gray("  Starting via launchctl..."));
-        try {
-          (0, import_node_child_process4.execSync)(`launchctl start ${LAUNCHD_LABEL}`, { stdio: "ignore" });
-          console.log(source_default.green("  \u2713 Started.\n"));
-        } catch {
-          console.log(source_default.red("  \u2717 Failed to start. Check: adhdev service logs --err\n"));
-        }
-      } else {
-        console.log(source_default.gray("  Start with: adhdev daemon\n"));
-      }
-      return;
-    }
-    console.log(source_default.cyan(`
-  Stopping daemon (PID ${health.pid})...`));
-    try {
-      process.kill(health.pid, "SIGTERM");
-    } catch {
-      console.log(source_default.yellow("  Could not send SIGTERM. Process may have already exited."));
-    }
-    await new Promise((r) => setTimeout(r, 2e3));
-    if (platform12 === "win32") {
-      const vbsPath = getWindowsVbsPath();
-      if (import_node_fs4.default.existsSync(vbsPath)) {
-        try {
-          (0, import_node_child_process4.execSync)(`wscript.exe "${vbsPath}"`, { stdio: "ignore", windowsHide: true });
-        } catch {
-        }
-      }
-    }
-    let restarted = false;
-    for (let i = 0; i < 8; i++) {
-      await new Promise((r) => setTimeout(r, 1e3));
-      const newHealth = await fetchHealth();
-      if (newHealth?.ok && newHealth.pid !== health.pid) {
-        restarted = true;
-        const info = getProcessInfo(newHealth.pid);
-        console.log(source_default.green(`  \u2713 Daemon restarted \u2014 new PID ${newHealth.pid}${info ? `, ${info.memMB} MB` : ""}`));
-        break;
-      }
-    }
-    if (!restarted) {
-      console.log(source_default.yellow("  \u26A0 Daemon did not restart within 10s."));
-      console.log(source_default.gray("  Check: adhdev service logs --err"));
-    }
-    console.log();
-  });
-}
-function formatBytes(bytes) {
-  if (bytes === 0) return "0 B";
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-
 // src/cli/doctor-commands.ts
+init_service_commands();
 function resolvePackageRoot() {
   return path39.resolve(__dirname, "..", "..");
 }
@@ -104518,6 +105026,9 @@ function registerCdpCommands(program2) {
   });
 }
 
+// src/cli/index.ts
+init_service_commands();
+
 // src/cli/mcp-commands.ts
 var import_node_child_process5 = require("child_process");
 var fs23 = __toESM(require("fs"));