@openclawbrain/openclaw 0.3.0 → 0.3.2

package/dist/src/daemon.d.ts

@@ -1,7 +1,9 @@
 /**
  * macOS launchd daemon management for OpenClawBrain.
  *
- * Manages a launchd user agent that runs `openclawbrain watch` in the background.
+ * Manages macOS launchd user agents that run `openclawbrain watch` in the background.
+ * Service identity is derived per activation root so one profile/service boundary
+ * does not collide with another.
  *
  * Commands:
  *   daemon start  — generate and load a launchd plist
@@ -10,6 +12,17 @@
  *   daemon logs   — tail the daemon log file
  */
 type DaemonCommandRunner = (command: string) => string;
+export interface DaemonServiceIdentity {
+    requestedActivationRoot: string;
+    canonicalActivationRoot: string;
+    activationRootHash: string;
+    activationRootSlug: string;
+    label: string;
+    plistFilename: string;
+    plistPath: string;
+    logPath: string;
+}
+export declare function buildDaemonServiceIdentity(activationRoot: string): DaemonServiceIdentity;
 export declare function setDaemonCommandRunnerForTesting(runner: DaemonCommandRunner | null): void;
 export type DaemonSubcommand = "start" | "stop" | "status" | "logs";
 export interface DaemonCliArgs {
@@ -19,6 +32,34 @@ export interface DaemonCliArgs {
     json: boolean;
     help: boolean;
 }
+export interface ManagedLearnerServiceInspection {
+    requestedActivationRoot: string;
+    canonicalActivationRoot: string;
+    serviceLabel: string;
+    plistPath: string;
+    logPath: string;
+    installed: boolean;
+    running: boolean;
+    pid: number | null;
+    configuredActivationRoot: string | null;
+    matchesRequestedActivationRoot: boolean | null;
+    launchctlAvailable: boolean;
+}
+export interface ManagedLearnerServiceEnsureResult {
+    state: "started" | "ensured" | "deferred";
+    reason: "started_exact_root" | "already_running_exact_root" | "launchctl_unavailable" | "launch_command_unavailable" | "launch_failed";
+    detail: string;
+    inspection: ManagedLearnerServiceInspection;
+}
+export interface ManagedLearnerServiceRemovalResult {
+    state: "removed" | "preserved" | "already_absent";
+    reason: "removed_exact_root" | "not_installed" | "configured_root_mismatch" | "launchctl_unavailable" | "stop_failed";
+    detail: string;
+    inspection: ManagedLearnerServiceInspection;
+}
+export declare function inspectManagedLearnerService(activationRoot: string): ManagedLearnerServiceInspection;
+export declare function ensureManagedLearnerServiceForActivationRoot(activationRoot: string): ManagedLearnerServiceEnsureResult;
+export declare function removeManagedLearnerServiceForActivationRoot(activationRoot: string): ManagedLearnerServiceRemovalResult;
 export declare function daemonStart(activationRoot: string, json: boolean): number;
 export declare function daemonStop(activationRoot: string, json: boolean): number;
 export declare function daemonStatus(activationRoot: string, json: boolean): number;

package/dist/src/daemon.js

@@ -1,7 +1,9 @@
 /**
  * macOS launchd daemon management for OpenClawBrain.
  *
- * Manages a launchd user agent that runs `openclawbrain watch` in the background.
+ * Manages macOS launchd user agents that run `openclawbrain watch` in the background.
+ * Service identity is derived per activation root so one profile/service boundary
+ * does not collide with another.
  *
  * Commands:
  *   daemon start  — generate and load a launchd plist
@@ -10,11 +12,13 @@
  *   daemon logs   — tail the daemon log file
  */
 import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, realpathSync, unlinkSync, writeFileSync } from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { loadTeacherSurface, resolveWatchSessionTailCursorPath, resolveWatchStateRoot, resolveWatchTeacherSnapshotPath } from "./index.js";
-const LABEL = "com.openclawbrain.daemon";
-const PLIST_FILENAME = `${LABEL}.plist`;
+const LABEL_PREFIX = "com.openclawbrain.daemon";
+const LOG_ROOT_DIRNAME = "daemon";
 const DEFAULT_SCAN_ROOT_DIRNAME = "event-exports";
 const BASELINE_STATE_BASENAME = "baseline-state.json";
 const SCANNER_CHECKPOINT_BASENAME = ".openclawbrain-scanner-checkpoint.json";
@@ -26,53 +30,138 @@ let daemonCommandRunner = DEFAULT_DAEMON_COMMAND_RUNNER;
 function getHomeDir() {
     return process.env.HOME ?? process.env.USERPROFILE ?? "~";
 }
-function getPlistPath() {
-    return path.join(getHomeDir(), "Library", "LaunchAgents", PLIST_FILENAME);
+function canonicalizeActivationRoot(activationRoot) {
+    const resolvedActivationRoot = path.resolve(activationRoot);
+    return existsSync(resolvedActivationRoot) ? safeRealpath(resolvedActivationRoot) : resolvedActivationRoot;
 }
-function getLogPath() {
-    return path.join(getHomeDir(), ".openclawbrain", "daemon.log");
+function sanitizeActivationRootSlug(value) {
+    const sanitized = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return sanitized.length > 0 ? sanitized.slice(0, 32) : "activation-root";
+}
+export function buildDaemonServiceIdentity(activationRoot) {
+    const requestedActivationRoot = path.resolve(activationRoot);
+    const canonicalActivationRoot = canonicalizeActivationRoot(requestedActivationRoot);
+    const activationRootHash = createHash("sha256").update(canonicalActivationRoot).digest("hex").slice(0, 12);
+    const activationRootSlug = sanitizeActivationRootSlug(path.basename(canonicalActivationRoot));
+    const label = `${LABEL_PREFIX}.${activationRootSlug}.${activationRootHash}`;
+    const plistFilename = `${label}.plist`;
+    return {
+        requestedActivationRoot,
+        canonicalActivationRoot,
+        activationRootHash,
+        activationRootSlug,
+        label,
+        plistFilename,
+        plistPath: path.join(getHomeDir(), "Library", "LaunchAgents", plistFilename),
+        logPath: path.join(getHomeDir(), ".openclawbrain", LOG_ROOT_DIRNAME, `${activationRootSlug}-${activationRootHash}.log`)
+    };
 }
 export function setDaemonCommandRunnerForTesting(runner) {
     daemonCommandRunner = runner ?? DEFAULT_DAEMON_COMMAND_RUNNER;
 }
 function getOpenclawbrainBinPath() {
-    // Prefer the resolved path of the currently running CLI
-    const selfBin = process.argv[1];
-    if (selfBin) {
-        // If running from dist/src/cli.js, the bin symlink resolves to the same thing
-        const dir = path.dirname(selfBin);
-        const candidate = path.join(dir, "..", "..", "node_modules", ".bin", "openclawbrain");
-        if (existsSync(candidate)) {
-            return path.resolve(candidate);
-        }
+    try {
+        const resolved = daemonCommandRunner("which openclawbrain").trim();
+        return resolved.length > 0 ? resolved : null;
     }
-    // Fall back to finding it on PATH
+    catch {
+        return null;
+    }
+}
+function safeRealpath(filePath) {
     try {
-        return daemonCommandRunner("which openclawbrain").trim();
+        return realpathSync(filePath);
     }
     catch {
-        return "openclawbrain";
+        return filePath;
+    }
+}
+function resolvePackageRoot(startDir) {
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        const packageJsonPath = path.join(currentDir, "package.json");
+        if (existsSync(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+                if (packageJson.name === "@openclawbrain/openclaw") {
+                    return currentDir;
+                }
+            }
+            catch {
+                // Ignore malformed package.json while searching upward for the real package root.
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
     }
 }
-function buildPlistXml(activationRoot) {
-    const logPath = getLogPath();
+function resolveCliScriptCandidate(candidatePath) {
+    if (typeof candidatePath !== "string" || candidatePath.trim().length === 0) {
+        return null;
+    }
+    const absoluteCandidate = path.resolve(candidatePath);
+    if (!existsSync(absoluteCandidate)) {
+        return null;
+    }
+    const resolvedCandidate = safeRealpath(absoluteCandidate);
+    const basename = path.basename(resolvedCandidate);
+    if (basename !== "cli.js" && basename !== "cli.cjs" && basename !== "cli.mjs") {
+        return null;
+    }
+    return resolvedCandidate;
+}
+function getOpenclawbrainCliScriptPath() {
+    const moduleFilePath = fileURLToPath(import.meta.url);
+    const moduleDir = path.dirname(moduleFilePath);
+    const packageRoot = resolvePackageRoot(moduleDir);
+    const candidates = [
+        process.argv[1],
+        path.join(moduleDir, "cli.js"),
+        packageRoot === null ? null : path.join(packageRoot, "dist", "src", "cli.js")
+    ];
+    for (const candidate of candidates) {
+        const resolved = resolveCliScriptCandidate(candidate);
+        if (resolved !== null) {
+            return resolved;
+        }
+    }
+    return null;
+}
+function resolveDaemonProgramArguments() {
+    const cliScriptPath = getOpenclawbrainCliScriptPath();
+    if (cliScriptPath !== null) {
+        return [process.execPath, cliScriptPath];
+    }
     const binPath = getOpenclawbrainBinPath();
+    if (binPath !== null) {
+        return [binPath];
+    }
+    return null;
+}
+function buildPlistXml(serviceIdentity, programArguments) {
+    const logPath = serviceIdentity.logPath;
     const homeDir = getHomeDir();
+    const daemonProgramArguments = [...programArguments, "watch", "--activation-root", serviceIdentity.requestedActivationRoot]
+        .map((argument) => `    <string>${argument}</string>`)
+        .join("\n");
     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>${LABEL}</string>
+  <string>${serviceIdentity.label}</string>
   <key>ProgramArguments</key>
   <array>
-    <string>${binPath}</string>
-    <string>watch</string>
-    <string>--activation-root</string>
-    <string>${activationRoot}</string>
+${daemonProgramArguments}
   </array>
   <key>WorkingDirectory</key>
-  <string>${activationRoot}</string>
+  <string>${serviceIdentity.requestedActivationRoot}</string>
   <key>StandardOutPath</key>
   <string>${logPath}</string>
   <key>StandardErrorPath</key>
@@ -92,12 +181,20 @@ function buildPlistXml(activationRoot) {
 </plist>
 `;
 }
-function ensureLogDir() {
-    const logDir = path.dirname(getLogPath());
+function ensureLogDir(logPath) {
+    const logDir = path.dirname(logPath);
     if (!existsSync(logDir)) {
         mkdirSync(logDir, { recursive: true });
     }
 }
+function hasLaunchctl() {
+    try {
+        return daemonCommandRunner("command -v launchctl").trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
 function launchctlLoad(plistPath) {
     try {
         daemonCommandRunner(`launchctl load -w ${JSON.stringify(plistPath)}`);
@@ -118,11 +215,11 @@ function launchctlUnload(plistPath) {
         return { ok: false, message: `Failed to unload plist: ${message}` };
     }
 }
-function getLaunchctlInfo() {
+function getLaunchctlInfo(label) {
     try {
         const output = daemonCommandRunner("launchctl list");
         for (const line of output.split("\n")) {
-            if (line.includes(LABEL)) {
+            if (line.includes(label)) {
                 const parts = line.trim().split(/\s+/);
                 const pidStr = parts[0];
                 const pid = pidStr && pidStr !== "-" ? parseInt(pidStr, 10) : null;
@@ -135,6 +232,166 @@ function getLaunchctlInfo() {
     }
     return { running: false, pid: null };
 }
+function inspectManagedLearnerServiceInternal(activationRoot) {
+    const serviceIdentity = buildDaemonServiceIdentity(activationRoot);
+    const configuredActivationRoot = readDaemonActivationRoot(serviceIdentity.plistPath);
+    const info = getLaunchctlInfo(serviceIdentity.label);
+    return {
+        requestedActivationRoot: serviceIdentity.requestedActivationRoot,
+        canonicalActivationRoot: serviceIdentity.canonicalActivationRoot,
+        serviceLabel: serviceIdentity.label,
+        plistPath: serviceIdentity.plistPath,
+        logPath: serviceIdentity.logPath,
+        installed: existsSync(serviceIdentity.plistPath),
+        running: info.running,
+        pid: info.pid,
+        configuredActivationRoot,
+        matchesRequestedActivationRoot: configuredActivationRoot === null
+            ? null
+            : canonicalizeActivationRoot(configuredActivationRoot) === serviceIdentity.canonicalActivationRoot,
+        launchctlAvailable: hasLaunchctl()
+    };
+}
+function startManagedLearnerService(activationRoot) {
+    const inspectionBeforeStart = inspectManagedLearnerServiceInternal(activationRoot);
+    const serviceIdentity = buildDaemonServiceIdentity(activationRoot);
+    if (!inspectionBeforeStart.launchctlAvailable) {
+        return {
+            ok: false,
+            message: "launchctl is unavailable on this host",
+            inspection: inspectionBeforeStart
+        };
+    }
+    const programArguments = resolveDaemonProgramArguments();
+    if (programArguments === null) {
+        return {
+            ok: false,
+            message: "Failed to resolve an OpenClawBrain CLI launch command.",
+            inspection: inspectionBeforeStart
+        };
+    }
+    const launchAgentsDir = path.dirname(inspectionBeforeStart.plistPath);
+    if (!existsSync(launchAgentsDir)) {
+        mkdirSync(launchAgentsDir, { recursive: true });
+    }
+    ensureLogDir(serviceIdentity.logPath);
+    const plistContent = buildPlistXml(serviceIdentity, programArguments);
+    writeFileSync(inspectionBeforeStart.plistPath, plistContent, "utf8");
+    const result = launchctlLoad(inspectionBeforeStart.plistPath);
+    if (!result.ok && !inspectionBeforeStart.installed) {
+        try {
+            unlinkSync(inspectionBeforeStart.plistPath);
+        }
+        catch {
+            // Best effort cleanup for failed first-time auto-start attempts.
+        }
+    }
+    return {
+        ok: result.ok,
+        message: result.message,
+        inspection: inspectManagedLearnerServiceInternal(activationRoot)
+    };
+}
+function stopManagedLearnerService(activationRoot) {
+    const inspectionBeforeStop = inspectManagedLearnerServiceInternal(activationRoot);
+    if (!inspectionBeforeStop.installed) {
+        return {
+            ok: true,
+            message: "No daemon plist found.",
+            inspection: inspectionBeforeStop
+        };
+    }
+    if (!inspectionBeforeStop.launchctlAvailable) {
+        return {
+            ok: false,
+            message: "launchctl is unavailable on this host",
+            inspection: inspectionBeforeStop
+        };
+    }
+    const result = launchctlUnload(inspectionBeforeStop.plistPath);
+    if (result.ok) {
+        try {
+            unlinkSync(inspectionBeforeStop.plistPath);
+        }
+        catch {
+            // best effort
+        }
+    }
+    return {
+        ok: result.ok,
+        message: result.message,
+        inspection: inspectManagedLearnerServiceInternal(activationRoot)
+    };
+}
+export function inspectManagedLearnerService(activationRoot) {
+    return inspectManagedLearnerServiceInternal(activationRoot);
+}
+export function ensureManagedLearnerServiceForActivationRoot(activationRoot) {
+    const inspection = inspectManagedLearnerServiceInternal(activationRoot);
+    if (inspection.matchesRequestedActivationRoot === true && inspection.running) {
+        return {
+            state: "ensured",
+            reason: "already_running_exact_root",
+            detail: `Learner auto-start already ensured for ${inspection.requestedActivationRoot}; the matching background learner service is running.`,
+            inspection
+        };
+    }
+    const startResult = startManagedLearnerService(activationRoot);
+    if (startResult.ok) {
+        return {
+            state: "started",
+            reason: "started_exact_root",
+            detail: `Started the background learner service for ${startResult.inspection.requestedActivationRoot}; passive learning can begin for this attached profile now.`,
+            inspection: startResult.inspection
+        };
+    }
+    const reason = !inspection.launchctlAvailable
+        ? "launchctl_unavailable"
+        : startResult.message === "Failed to resolve an OpenClawBrain CLI launch command."
+            ? "launch_command_unavailable"
+            : "launch_failed";
+    return {
+        state: "deferred",
+        reason,
+        detail: `Learner auto-start deferred for ${inspection.requestedActivationRoot}: ${startResult.message}`,
+        inspection: startResult.inspection
+    };
+}
+export function removeManagedLearnerServiceForActivationRoot(activationRoot) {
+    const inspection = inspectManagedLearnerServiceInternal(activationRoot);
+    if (!inspection.installed) {
+        return {
+            state: "already_absent",
+            reason: "not_installed",
+            detail: `No background learner service is installed for ${inspection.requestedActivationRoot}.`,
+            inspection
+        };
+    }
+    if (inspection.matchesRequestedActivationRoot === false) {
+        return {
+            state: "preserved",
+            reason: "configured_root_mismatch",
+            detail: `Preserved the background learner service because ${inspection.plistPath} is configured for ${inspection.configuredActivationRoot}, ` +
+                `not the requested exact root ${inspection.requestedActivationRoot}.`,
+            inspection
+        };
+    }
+    const stopResult = stopManagedLearnerService(activationRoot);
+    if (stopResult.ok) {
+        return {
+            state: "removed",
+            reason: "removed_exact_root",
+            detail: `Removed the background learner service for ${stopResult.inspection.requestedActivationRoot}.`,
+            inspection: stopResult.inspection
+        };
+    }
+    return {
+        state: "preserved",
+        reason: inspection.launchctlAvailable ? "stop_failed" : "launchctl_unavailable",
+        detail: `Preserved the background learner service for ${inspection.requestedActivationRoot}: ${stopResult.message}`,
+        inspection: stopResult.inspection
+    };
+}
 function readLastLines(filePath, count) {
     if (!existsSync(filePath))
         return [];
@@ -351,16 +608,36 @@ function readWatchStateSummary(activationRoot) {
 }
 // ─── Subcommand implementations ─────────────────────────────────────────────
 export function daemonStart(activationRoot, json) {
-    const plistPath = getPlistPath();
-    const logPath = getLogPath();
+    const serviceIdentity = buildDaemonServiceIdentity(activationRoot);
+    const plistPath = serviceIdentity.plistPath;
+    const logPath = serviceIdentity.logPath;
+    const programArguments = resolveDaemonProgramArguments();
+    if (programArguments === null) {
+        const message = "Failed to resolve an OpenClawBrain CLI launch command. Install/build the local package or make `openclawbrain` available on PATH.";
+        if (json) {
+            console.log(JSON.stringify({
+                command: "daemon start",
+                ok: false,
+                plistPath,
+                logPath,
+                activationRoot: serviceIdentity.requestedActivationRoot,
+                serviceLabel: serviceIdentity.label,
+                message,
+            }, null, 2));
+        }
+        else {
+            console.error(`✗ ${message}`);
+        }
+        return 1;
+    }
     // Ensure LaunchAgents dir exists
     const launchAgentsDir = path.dirname(plistPath);
     if (!existsSync(launchAgentsDir)) {
         mkdirSync(launchAgentsDir, { recursive: true });
     }
-    ensureLogDir();
+    ensureLogDir(logPath);
     // Write the plist
-    const plistContent = buildPlistXml(activationRoot);
+    const plistContent = buildPlistXml(serviceIdentity, programArguments);
     writeFileSync(plistPath, plistContent, "utf8");
     // Load it
     const result = launchctlLoad(plistPath);
@@ -370,16 +647,18 @@ export function daemonStart(activationRoot, json) {
             ok: result.ok,
             plistPath,
             logPath,
-            activationRoot,
+            activationRoot: serviceIdentity.requestedActivationRoot,
+            serviceLabel: serviceIdentity.label,
             message: result.message,
         }, null, 2));
     }
     else {
         if (result.ok) {
             console.log(`✓ Daemon started`);
+            console.log(`  Label: ${serviceIdentity.label}`);
             console.log(`  Plist: ${plistPath}`);
             console.log(`  Log:   ${logPath}`);
-            console.log(`  Root:  ${activationRoot}`);
+            console.log(`  Root:  ${serviceIdentity.requestedActivationRoot}`);
         }
         else {
             console.error(`✗ ${result.message}`);
@@ -388,11 +667,19 @@ export function daemonStart(activationRoot, json) {
     return result.ok ? 0 : 1;
 }
 export function daemonStop(activationRoot, json) {
-    const plistPath = getPlistPath();
+    const serviceIdentity = buildDaemonServiceIdentity(activationRoot);
+    const plistPath = serviceIdentity.plistPath;
     if (!existsSync(plistPath)) {
         const msg = "No daemon plist found. Daemon is not installed.";
         if (json) {
-            console.log(JSON.stringify({ command: "daemon stop", ok: false, activationRoot, message: msg }, null, 2));
+            console.log(JSON.stringify({
+                command: "daemon stop",
+                ok: false,
+                activationRoot: serviceIdentity.requestedActivationRoot,
+                serviceLabel: serviceIdentity.label,
+                plistPath,
+                message: msg
+            }, null, 2));
         }
         else {
             console.log(msg);
@@ -412,7 +699,8 @@ export function daemonStop(activationRoot, json) {
     if (json) {
         console.log(JSON.stringify({
             command: "daemon stop",
-            activationRoot,
+            activationRoot: serviceIdentity.requestedActivationRoot,
+            serviceLabel: serviceIdentity.label,
             ok: result.ok,
             plistPath,
             message: result.message,
@@ -421,6 +709,7 @@ export function daemonStop(activationRoot, json) {
     else {
         if (result.ok) {
             console.log(`✓ Daemon stopped and plist removed.`);
+            console.log(`  Label: ${serviceIdentity.label}`);
         }
         else {
             console.error(`✗ ${result.message}`);
@@ -429,22 +718,26 @@ export function daemonStop(activationRoot, json) {
     return result.ok ? 0 : 1;
 }
 export function daemonStatus(activationRoot, json) {
-    const plistPath = getPlistPath();
-    const logPath = getLogPath();
+    const serviceIdentity = buildDaemonServiceIdentity(activationRoot);
+    const plistPath = serviceIdentity.plistPath;
+    const logPath = serviceIdentity.logPath;
     const plistInstalled = existsSync(plistPath);
-    const info = getLaunchctlInfo();
+    const info = getLaunchctlInfo(serviceIdentity.label);
     const lastLogLines = readLastLines(logPath, 5);
     const configuredActivationRoot = readDaemonActivationRoot(plistPath);
-    const requestedActivationRoot = path.resolve(activationRoot);
+    const requestedActivationRoot = serviceIdentity.requestedActivationRoot;
     const watchStatePaths = getWatchStatePaths(requestedActivationRoot);
     const watchState = readWatchStateSummary(requestedActivationRoot);
-    const matchesRequestedActivationRoot = configuredActivationRoot === null ? null : path.resolve(configuredActivationRoot) === requestedActivationRoot;
+    const matchesRequestedActivationRoot = configuredActivationRoot === null
+        ? null
+        : canonicalizeActivationRoot(configuredActivationRoot) === serviceIdentity.canonicalActivationRoot;
     if (json) {
         console.log(JSON.stringify({
             command: "daemon status",
             installed: plistInstalled,
             running: info.running,
             pid: info.pid,
+            serviceLabel: serviceIdentity.label,
             plistPath,
             logPath,
             activationRoot: requestedActivationRoot,
@@ -463,6 +756,7 @@ export function daemonStatus(activationRoot, json) {
             console.log(`  PID: ${info.pid}`);
         }
         if (plistInstalled) {
+            console.log(`  Label: ${serviceIdentity.label}`);
             console.log(`  Plist: ${plistPath}`);
         }
         console.log(`  Requested root: ${requestedActivationRoot}`);
@@ -535,11 +829,20 @@ export function daemonStatus(activationRoot, json) {
     return 0;
 }
 export function daemonLogs(activationRoot, json) {
-    const logPath = getLogPath();
+    const serviceIdentity = buildDaemonServiceIdentity(activationRoot);
+    const logPath = serviceIdentity.logPath;
     if (!existsSync(logPath)) {
         const msg = `No log file found at ${logPath}`;
         if (json) {
-            console.log(JSON.stringify({ command: "daemon logs", ok: false, activationRoot, logPath, message: msg, lines: [] }, null, 2));
+            console.log(JSON.stringify({
+                command: "daemon logs",
+                ok: false,
+                activationRoot: serviceIdentity.requestedActivationRoot,
+                serviceLabel: serviceIdentity.label,
+                logPath,
+                message: msg,
+                lines: []
+            }, null, 2));
         }
         else {
             console.log(msg);
@@ -548,7 +851,14 @@ export function daemonLogs(activationRoot, json) {
     }
     const lines = readLastLines(logPath, 50);
     if (json) {
-        console.log(JSON.stringify({ command: "daemon logs", ok: true, activationRoot, logPath, lines }, null, 2));
+        console.log(JSON.stringify({
+            command: "daemon logs",
+            ok: true,
+            activationRoot: serviceIdentity.requestedActivationRoot,
+            serviceLabel: serviceIdentity.label,
+            logPath,
+            lines
+        }, null, 2));
     }
     else {
         if (lines.length === 0) {
@@ -595,7 +905,7 @@ export function daemonHelp() {
         "  start   Generate a macOS launchd plist and start the daemon (runs openclawbrain watch).",
         "  stop    Stop the daemon and remove the launchd plist.",
         "  status  Show whether the daemon is running, its PID, and recent log lines.",
-        "  logs    Show the last 50 lines of the daemon log (~/.openclawbrain/daemon.log).",
+        "  logs    Show the last 50 lines of the per-activation-root daemon log under ~/.openclawbrain/daemon/.",
         "",
         "Options:",
         "  --activation-root <path>  Explicit activation root for the wrapped watch daemon.",