pulseed 0.6.4 → 0.6.6

package/dist/interface/cli/commands/daemon.js

@@ -1,4 +1,4 @@
-// ─── pulseed daemon commands (start, stop, cron, status) ───
+// ─── pulseed daemon commands (start, stop, restart, cron, status) ───
 import { parseArgs } from "node:util";
 import { spawn } from "node:child_process";
 import * as path from "node:path";
@@ -6,13 +6,14 @@ import { readJsonFileOrNull } from "../../../base/utils/json-io.js";
 import { DaemonStateSchema, DaemonConfigSchema } from "../../../base/types/daemon.js";
 import { Logger } from "../../../runtime/logger.js";
 import { DaemonRunner } from "../../../runtime/daemon/runner.js";
+import { readShutdownMarkerFile } from "../../../runtime/daemon/persistence.js";
 import { PIDManager } from "../../../runtime/pid-manager.js";
 import { EventServer } from "../../../runtime/event/server.js";
 import { IngressGateway, SlackChannelAdapter, loadBuiltinGatewayIntegrations, } from "../../../runtime/gateway/index.js";
 import { ScheduleEngine } from "../../../runtime/schedule/engine.js";
 import { RuntimeWatchdog } from "../../../runtime/watchdog.js";
 import { LeaderLockManager } from "../../../runtime/leader-lock-manager.js";
-import { ProactiveInterventionStore, RuntimeHealthStore } from "../../../runtime/store/index.js";
+import { DaemonStateStore, ProactiveInterventionStore, RuntimeHealthStore, } from "../../../runtime/store/index.js";
 import { isDaemonRunning, probeDaemonHealth } from "../../../runtime/daemon/client.js";
 import { PluginLoader } from "../../../runtime/plugin-loader.js";
 import { NotifierRegistry } from "../../../runtime/notifier-registry.js";
@@ -27,55 +28,48 @@ import { getCliLogger } from "../cli-logger.js";
 import { getPulseedDirPath, getLogsDir, getEventsDir } from "../../../base/utils/paths.js";
 import { summarizeTaskOutcomeLedgers } from "../../../orchestrator/execution/task/task-outcome-ledger.js";
 import { createBuiltinTools } from "../../../tools/index.js";
-import { formatCapabilityLabel, formatDurationMs, formatGoalMode, formatKpiCompactLine, formatLongRunHealthLines, formatPercent, formatRelativeTime, formatRelativeTimestamp, formatTaskFailureReasonCounts, formatTaskOutcomeLine, formatTaskSuccessRateLine, formatUptime, isPidAlive, loadDaemonConfig, readSupervisorState, resolveDaemonRuntimeRoot, } from "./daemon-shared.js";
+import { formatAbsoluteRelativeTimestamp, formatCapabilityLabel, formatDurationMs, formatGoalMode, formatKpiCompactLine, formatLongRunHealthLines, formatPercent, formatRelativeTime, formatRelativeTimestamp, formatTaskFailureReasonCounts, formatTaskOutcomeLine, formatTaskSuccessRateLine, formatUptime, isPidAlive, loadDaemonConfig, readSupervisorState, resolveDaemonRuntimeRoot, } from "./daemon-shared.js";
+import { LIVE_RUNTIME_OVERRIDES_STALE_HEALTH_REASON, STALE_RUNTIME_HEALTH_REASON, formatControlDbSchemaDriftMessage, formatHistoricalSnapshotContext, parseHistoricalObservationTime, reconcileRuntimeHealthForDisplay, } from "./daemon-status-health.js";
 const WATCHDOG_CHILD_ENV = "PULSEED_WATCHDOG_CHILD";
-const STALE_RUNTIME_HEALTH_REASON = "live PID inspection reports runtime stopped; stored health snapshot is historical";
-function reconcileRuntimeHealthForDisplay(snapshot, opts) {
-    if (!snapshot || opts.runtimeAlive) {
-        return snapshot;
-    }
-    const checkedAt = Date.now();
-    const staleRuntimePid = opts.runtimePid ?? snapshot.long_running?.signals.process.pid;
-    const kpi = snapshot.kpi
-        ? {
-            ...snapshot.kpi,
-            process_alive: {
-                ...snapshot.kpi.process_alive,
-                status: "failed",
-                checked_at: checkedAt,
-                last_failed_at: checkedAt,
-                reason: STALE_RUNTIME_HEALTH_REASON,
-            },
-            degraded_at: snapshot.kpi.degraded_at ?? checkedAt,
-        }
-        : undefined;
-    const longRunning = snapshot.long_running
-        ? {
-            ...snapshot.long_running,
-            summary: snapshot.long_running.signals.resumable ? "dead_but_resumable" : "dead_needs_intervention",
-            checked_at: checkedAt,
-            signals: {
-                ...snapshot.long_running.signals,
-                process: {
-                    ...snapshot.long_running.signals.process,
-                    status: "dead",
-                    pid: staleRuntimePid,
-                    checked_at: checkedAt,
-                    observed_at: checkedAt,
-                    reason: STALE_RUNTIME_HEALTH_REASON,
-                },
-            },
-        }
-        : undefined;
-    return {
-        ...snapshot,
-        status: "failed",
-        checked_at: checkedAt,
-        kpi,
-        long_running: longRunning,
-    };
+function resolveStatusArtifactExpectation(params) {
+    if (params.liveRuntimeStopped) {
+        return { state: "unknown", reason: "historical_runtime_snapshot" };
+    }
+    if (params.activeGoalIds.length > 0) {
+        return { state: "expected", reason: "active_goal" };
+    }
+    if (params.activeWorkerCount > 0) {
+        return { state: "expected", reason: "active_worker" };
+    }
+    if (params.daemonStatus === "idle") {
+        return { state: "none", reason: "idle_no_worker" };
+    }
+    if (params.workerSnapshotAvailable) {
+        return { state: "none", reason: "idle_no_worker" };
+    }
+    return { state: "unknown", reason: "worker_snapshot_unavailable" };
 }
-export async function cmdStart(stateManager, characterConfigManager, args) {
+export function parseDaemonPositiveInteger(raw, label) {
+    const normalized = typeof raw === "string" ? raw.trim() : "";
+    if (!/^[0-9]+$/.test(normalized)) {
+        throw new Error(`${label} must be a positive integer`);
+    }
+    const parsed = Number(normalized);
+    if (!Number.isSafeInteger(parsed) || parsed < 1) {
+        throw new Error(`${label} must be a positive integer`);
+    }
+    return parsed;
+}
+function readDaemonPositiveInteger(raw, label) {
+    try {
+        return parseDaemonPositiveInteger(raw, label);
+    }
+    catch (err) {
+        getCliLogger().error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+export async function cmdStart(stateManager, characterConfigManager, args, options = {}) {
     let values;
     try {
         ({ values } = parseArgs({
@@ -96,7 +90,7 @@ export async function cmdStart(stateManager, characterConfigManager, args) {
     }
     catch (err) {
         getCliLogger().error(formatOperationError("parse start command arguments", err));
-        values = {};
+        process.exit(1);
     }
     const goalIds = values.goal || [];
     // Gap 1: Load DaemonConfig from --config path (if provided)
@@ -123,21 +117,13 @@ export async function cmdStart(stateManager, characterConfigManager, args) {
         daemonConfig = await loadDaemonConfig(baseDir);
     }
     // Merge CLI flag overrides into daemonConfig
-    if (values["check-interval-ms"]) {
-        const parsed = parseInt(values["check-interval-ms"], 10);
-        if (isNaN(parsed) || parsed <= 0) {
-            getCliLogger().error("--check-interval-ms must be a positive integer");
-            process.exit(1);
-        }
+    if (values["check-interval-ms"] !== undefined) {
+        const parsed = readDaemonPositiveInteger(values["check-interval-ms"], "--check-interval-ms");
         daemonConfig = daemonConfig ?? {};
         daemonConfig.check_interval_ms = parsed;
     }
-    if (values["iterations-per-cycle"]) {
-        const parsed = parseInt(values["iterations-per-cycle"], 10);
-        if (isNaN(parsed) || parsed <= 0) {
-            getCliLogger().error("--iterations-per-cycle must be a positive integer");
-            process.exit(1);
-        }
+    if (values["iterations-per-cycle"] !== undefined) {
+        const parsed = readDaemonPositiveInteger(values["iterations-per-cycle"], "--iterations-per-cycle");
         daemonConfig = daemonConfig ?? {};
         daemonConfig.iterations_per_cycle = parsed;
         if (values.resident === true) {
@@ -151,12 +137,8 @@ export async function cmdStart(stateManager, characterConfigManager, args) {
         daemonConfig = daemonConfig ?? {};
         daemonConfig.run_policy = { mode: "resident", max_iterations: null };
     }
-    if (values["max-concurrent-goals"]) {
-        const parsed = parseInt(values["max-concurrent-goals"], 10);
-        if (isNaN(parsed) || parsed <= 0) {
-            getCliLogger().error("--max-concurrent-goals must be a positive integer");
-            process.exit(1);
-        }
+    if (values["max-concurrent-goals"] !== undefined) {
+        const parsed = readDaemonPositiveInteger(values["max-concurrent-goals"], "--max-concurrent-goals");
         daemonConfig = daemonConfig ?? {};
         daemonConfig.max_concurrent_goals = parsed;
     }
@@ -171,12 +153,16 @@ export async function cmdStart(stateManager, characterConfigManager, args) {
     const logger = new Logger({
         dir: getLogsDir(baseDir),
     });
+    const schemaDriftMessage = formatControlDbSchemaDriftMessage(baseDir);
+    if (schemaDriftMessage) {
+        getCliLogger().error(schemaDriftMessage);
+        process.exit(1);
+    }
     // --detach: spawn a detached process and exit immediately.
     // The detached process becomes the watchdog parent.
     if (values.detach) {
         const scriptPath = process.argv[1];
-        const childArgs = process.argv
-            .slice(2)
+        const childArgs = (options.childCommandArgs ?? process.argv.slice(2))
             .filter((arg) => arg !== "--detach" && arg !== "-d");
         const child = spawn(process.execPath, [scriptPath, ...childArgs], {
             detached: true,
@@ -201,10 +187,10 @@ export async function cmdStart(stateManager, characterConfigManager, args) {
     }
     if (shouldUseWatchdog) {
         const runtimeRoot = resolveDaemonRuntimeRoot(baseDir, resolvedDaemonConfig.runtime_root);
-        const healthStore = new RuntimeHealthStore(runtimeRoot);
-        const leaderLockManager = new LeaderLockManager(runtimeRoot);
+        const healthStore = new RuntimeHealthStore(runtimeRoot, { controlBaseDir: baseDir });
+        const leaderLockManager = new LeaderLockManager(runtimeRoot, undefined, { controlBaseDir: baseDir });
         const scriptPath = process.argv[1];
-        const childArgs = process.argv.slice(2);
+        const childArgs = options.childCommandArgs ?? process.argv.slice(2);
         const healthProbe = resolvedDaemonConfig.event_server_port > 0
             ? async () => {
                 const probe = await probeDaemonHealth({
@@ -223,6 +209,10 @@ export async function cmdStart(stateManager, characterConfigManager, args) {
             leaderLockManager,
             logger,
             healthProbe,
+            preStartCheck: async () => {
+                const detail = formatControlDbSchemaDriftMessage(baseDir);
+                return detail ? { ok: false, detail } : { ok: true };
+            },
             startChild: () => spawn(process.execPath, [scriptPath, ...childArgs], {
                 stdio: "inherit",
                 env: {
@@ -292,6 +282,16 @@ export async function cmdStart(stateManager, characterConfigManager, args) {
         eventsDir: getEventsDir(daemonBaseDir),
         runtimeRoot: resolveDaemonRuntimeRoot(daemonBaseDir, resolvedDaemonConfig.runtime_root),
         stateManager: deps.stateManager,
+        healthStatusProvider: () => {
+            const schemaDrift = formatControlDbSchemaDriftMessage(daemonBaseDir);
+            return schemaDrift
+                ? {
+                    status: "failed",
+                    reason: "unsupported_control_db_schema",
+                    detail: schemaDrift,
+                }
+                : { status: "ok" };
+        },
     }, logger);
     const gateway = new IngressGateway(logger);
     const builtinGatewayIntegrations = await loadBuiltinGatewayIntegrations(daemonBaseDir, logger);
@@ -402,15 +402,31 @@ export async function cmdStart(stateManager, characterConfigManager, args) {
 }
 export async function cmdDaemonStatus(_args) {
     const baseDir = getPulseedDirPath();
-    const statePath = path.join(baseDir, "daemon-state.json");
+    const schemaDriftMessage = formatControlDbSchemaDriftMessage(baseDir);
+    if (schemaDriftMessage) {
+        console.log([
+            "PulSeed Daemon Status",
+            "\u2500".repeat(21),
+            "Status:          schema drift",
+            schemaDriftMessage,
+        ].join("\n"));
+        return;
+    }
     const pidManager = new PIDManager(baseDir);
     const pidStatus = await pidManager.inspect();
     const runtimePid = pidStatus.runtimePid ?? pidStatus.info?.pid ?? null;
     const watchdogPid = pidStatus.info?.watchdog_pid ?? pidStatus.ownerPid ?? null;
     const runtimeAlive = isPidAlive(pidStatus, runtimePid);
     const watchdogAlive = isPidAlive(pidStatus, watchdogPid);
-    const raw = await readJsonFileOrNull(statePath);
-    if (raw === null) {
+    let loadedState;
+    try {
+        loadedState = await new DaemonStateStore(baseDir).load();
+    }
+    catch (error) {
+        console.error(`Invalid daemon state: ${error instanceof Error ? error.message : String(error)}`);
+        return;
+    }
+    if (loadedState === null) {
         if (!runtimeAlive && !watchdogAlive) {
             console.log("No daemon state found");
             return;
@@ -419,10 +435,10 @@ export async function cmdDaemonStatus(_args) {
             console.log(`Daemon watchdog is running, but runtime child is restarting (PID: ${runtimePid ?? "unknown"})`);
             return;
         }
-        console.log("Daemon process is running, but daemon-state.json is missing");
+        console.log("Daemon process is running, but daemon state is missing");
         return;
     }
-    const parsed = DaemonStateSchema.safeParse(raw);
+    const parsed = DaemonStateSchema.safeParse(loadedState);
     if (!parsed.success) {
         console.error(`Invalid daemon state: ${parsed.error.message}`);
         return;
@@ -432,16 +448,20 @@ export async function cmdDaemonStatus(_args) {
     const resolvedRuntimeAlive = isPidAlive(pidStatus, resolvedRuntimePid);
     // Load daemon config for config section display
     const cfg = await loadDaemonConfig(baseDir);
-    const runtimeRoot = resolveDaemonRuntimeRoot(baseDir, cfg.runtime_root);
-    const storedRuntimeHealth = await new RuntimeHealthStore(runtimeRoot).loadSnapshot();
+    const runtimeRoot = data.runtime_root ?? resolveDaemonRuntimeRoot(baseDir, cfg.runtime_root);
+    const storedRuntimeHealth = await new RuntimeHealthStore(runtimeRoot, { controlBaseDir: baseDir }).loadSnapshot();
     const runtimeHealth = reconcileRuntimeHealthForDisplay(storedRuntimeHealth, {
         runtimeAlive: resolvedRuntimeAlive,
         runtimePid: resolvedRuntimePid,
     });
     const runtimeHealthReconciled = storedRuntimeHealth !== runtimeHealth
         && (storedRuntimeHealth?.kpi !== undefined || storedRuntimeHealth?.long_running !== undefined);
-    const proactiveSummary = await new ProactiveInterventionStore(runtimeRoot).summarize();
-    const supervisorState = await readSupervisorState(runtimeRoot);
+    const runtimeHealthReconciliationReason = resolvedRuntimeAlive
+        ? LIVE_RUNTIME_OVERRIDES_STALE_HEALTH_REASON
+        : STALE_RUNTIME_HEALTH_REASON;
+    const proactiveSummary = await new ProactiveInterventionStore(runtimeRoot, { controlBaseDir: baseDir }).summarize();
+    const supervisorState = await readSupervisorState(runtimeRoot, baseDir);
+    const shutdownMarker = await readShutdownMarkerFile(baseDir);
     const taskKpis = await summarizeTaskOutcomeLedgers(baseDir);
     const safePauseGoals = Object.values(data.safe_pause_goals ?? {});
     const hasPauseRequested = safePauseGoals.some((pause) => pause.state === "pause_requested");
@@ -468,6 +488,15 @@ export async function cmdDaemonStatus(_args) {
         "\u2500".repeat(21),
         `Status:          ${status} (PID: ${resolvedRuntimePid})`,
     ];
+    const liveRuntimeStopped = status === "stopped" || status === "crashed";
+    const statusCheckedAt = Date.now();
+    const historicalSnapshotContext = liveRuntimeStopped
+        ? {
+            lastObservedAt: parseHistoricalObservationTime(data.last_loop_at),
+            stoppedAt: shutdownMarker?.timestamp,
+            checkedAt: statusCheckedAt,
+        }
+        : null;
     if (watchdogPid && watchdogPid !== resolvedRuntimePid) {
         lines.push(`Watchdog PID:    ${watchdogPid}${watchdogAlive ? "" : " (missing)"}`);
     }
@@ -477,11 +506,23 @@ export async function cmdDaemonStatus(_args) {
         }
         lines.push(`Started:         ${data.started_at}`);
     }
+    if (liveRuntimeStopped) {
+        if (shutdownMarker?.timestamp) {
+            lines.push(`Stopped:         ${shutdownMarker.timestamp} (${formatRelativeTime(shutdownMarker.timestamp)})`);
+        }
+        lines.push("Live runtime:    stopped; snapshot fields below are historical until the daemon restarts");
+    }
     lines.push("");
     lines.push(`Loops:           ${data.loop_count} cycles completed`);
-    const activeWorkers = resolvedRuntimeAlive
-        ? (supervisorState?.workers ?? []).filter((worker) => worker.goalId !== null)
-        : [];
+    const snapshotWorkers = (supervisorState?.workers ?? []).filter((worker) => worker.goalId !== null);
+    const activeWorkers = resolvedRuntimeAlive ? snapshotWorkers : [];
+    const artifactExpectation = resolveStatusArtifactExpectation({
+        activeGoalIds: data.active_goals,
+        activeWorkerCount: activeWorkers.length,
+        daemonStatus: data.status,
+        liveRuntimeStopped,
+        workerSnapshotAvailable: supervisorState !== null,
+    });
     if (activeWorkers.length > 0) {
         lines.push(`In flight:       ${activeWorkers.length} worker${activeWorkers.length === 1 ? "" : "s"} active`);
         for (const worker of activeWorkers) {
@@ -490,10 +531,28 @@ export async function cmdDaemonStatus(_args) {
             lines.push(`  Worker ${worker.workerId}: ${worker.goalId} (${started}${progress})`);
         }
     }
+    if (liveRuntimeStopped && snapshotWorkers.length > 0) {
+        const workerHistoricalContext = formatHistoricalSnapshotContext({
+            lastObservedAt: supervisorState?.updatedAt,
+            stoppedAt: shutdownMarker?.timestamp,
+            checkedAt: statusCheckedAt,
+        });
+        const observedAt = supervisorState?.updatedAt
+            ? ` observed ${formatRelativeTimestamp(supervisorState.updatedAt)}`
+            : "";
+        lines.push(`Historical in-flight: ${snapshotWorkers.length} stale worker${snapshotWorkers.length === 1 ? "" : "s"} from stopped snapshot${observedAt}${workerHistoricalContext}`);
+        for (const worker of snapshotWorkers) {
+            const started = worker.startedAt > 0 ? formatRelativeTimestamp(worker.startedAt) : "unknown start";
+            const progress = worker.iterations > 0 ? `, ${worker.iterations} iteration${worker.iterations === 1 ? "" : "s"}` : "";
+            lines.push(`  Stale worker ${worker.workerId}: ${worker.goalId} (${started}${progress})`);
+        }
+    }
     if (data.last_loop_at) {
         lines.push(`Last cycle:      ${formatRelativeTime(data.last_loop_at)}`);
     }
-    lines.push(`Active goals:    ${data.active_goals.join(", ") || "(none)"}`);
+    lines.push(liveRuntimeStopped
+        ? `Historical active goals: ${data.active_goals.join(", ") || "(none)"}${formatHistoricalSnapshotContext(historicalSnapshotContext)}`
+        : `Active goals:    ${data.active_goals.join(", ") || "(none)"}`);
     const waitingGoals = data.waiting_goals ?? [];
     if (waitingGoals.length > 0
         || data.next_observe_at
@@ -501,7 +560,7 @@ export async function cmdDaemonStatus(_args) {
         || data.last_wait_reason
         || data.approval_pending_count) {
         lines.push("");
-        lines.push("Wait status:");
+        lines.push(liveRuntimeStopped ? "Historical wait status:" : "Wait status:");
         lines.push(`  Waiting goals:  ${waitingGoals.length}`);
         if (data.next_observe_at) {
             lines.push(`  Next observe:   ${formatRelativeTime(data.next_observe_at)}`);
@@ -570,7 +629,7 @@ export async function cmdDaemonStatus(_args) {
         lines.push("");
         lines.push("Runtime health:");
         if (runtimeHealthReconciled) {
-            lines.push(`  Snapshot note:  ${STALE_RUNTIME_HEALTH_REASON}.`);
+            lines.push(`  Snapshot note:  ${runtimeHealthReconciliationReason}.`);
         }
         lines.push(`  ${formatCapabilityLabel("Process alive:", runtimeHealth.kpi, "process_alive")}`);
         lines.push(`  ${formatCapabilityLabel("Accept command:", runtimeHealth.kpi, "command_acceptance")}`);
@@ -585,24 +644,29 @@ export async function cmdDaemonStatus(_args) {
             lines.push(`  Important task success rate: ${formatTaskOutcomeLine(taskOutcome)}`);
         }
         if (runtimeHealth.kpi.degraded_at !== undefined) {
-            lines.push(`  Degraded at:     ${new Date(runtimeHealth.kpi.degraded_at).toISOString()} (${formatRelativeTimestamp(runtimeHealth.kpi.degraded_at)})`);
+            lines.push(`  Degraded at:     ${formatAbsoluteRelativeTimestamp(runtimeHealth.kpi.degraded_at)}`);
         }
         if (runtimeHealth.kpi.recovered_at !== undefined) {
-            lines.push(`  Recovered at:    ${new Date(runtimeHealth.kpi.recovered_at).toISOString()} (${formatRelativeTimestamp(runtimeHealth.kpi.recovered_at)})`);
+            lines.push(`  Recovered at:    ${formatAbsoluteRelativeTimestamp(runtimeHealth.kpi.recovered_at)}`);
         }
     }
     if (runtimeHealth?.long_running) {
         lines.push("");
         lines.push("Long-run health:");
         if (runtimeHealthReconciled) {
-            lines.push(`  Snapshot note:  ${STALE_RUNTIME_HEALTH_REASON}.`);
+            lines.push(`  Snapshot note:  ${runtimeHealthReconciliationReason}.`);
         }
-        lines.push(...formatLongRunHealthLines(runtimeHealth.long_running));
+        lines.push(...formatLongRunHealthLines(runtimeHealth.long_running, {
+            historical: liveRuntimeStopped,
+            artifactExpectation,
+        }));
     }
     if (taskKpis.total_tasks > 0) {
         lines.push("");
         lines.push("Task KPIs:");
-        lines.push(`  In-flight:       ${taskKpis.inflight_tasks}/${taskKpis.total_tasks}`);
+        lines.push(liveRuntimeStopped
+            ? `  Historical in-flight: ${taskKpis.inflight_tasks}/${taskKpis.total_tasks} (stale snapshot)${formatHistoricalSnapshotContext(historicalSnapshotContext)}`
+            : `  In-flight:       ${taskKpis.inflight_tasks}/${taskKpis.total_tasks}`);
         lines.push(`  Success rate:    ${taskKpis.succeeded}/${taskKpis.terminal_tasks} (${formatPercent(taskKpis.success_rate)})`);
         lines.push(`  Retry rate:      ${taskKpis.retried}/${taskKpis.total_tasks} (${formatPercent(taskKpis.retry_rate)})`);
         lines.push(`  Abandoned rate:  ${taskKpis.abandoned}/${taskKpis.terminal_tasks} (${formatPercent(taskKpis.abandoned_rate)})`);
@@ -648,27 +712,53 @@ export async function cmdDaemonStatus(_args) {
     lines.push(`Last error:      ${data.last_error ?? "none"}`);
     console.log(lines.join("\n"));
 }
-export async function cmdStop(_args) {
+async function stopDaemonRuntimeForCli() {
     const pidManager = new PIDManager(getPulseedDirPath());
     const stopResult = await pidManager.stopRuntime();
     if (!stopResult.info || stopResult.sentSignalsTo.length === 0) {
-        console.log("No running daemon found");
-        return;
+        return { status: "not_running", messages: ["No running daemon found"] };
     }
     const displayPid = stopResult.runtimePid ?? stopResult.ownerPid ?? stopResult.info.pid;
-    console.log(`Stopping daemon (PID: ${displayPid})...`);
+    const messages = [`Stopping daemon (PID: ${displayPid})...`];
     if (!stopResult.stopped) {
-        console.log(`Daemon still running (PIDs: ${stopResult.alivePids.join(", ")})`);
-        return;
+        messages.push(`Daemon still running (PIDs: ${stopResult.alivePids.join(", ")})`);
+        return { status: "failed", messages };
     }
     if (stopResult.forced) {
-        console.log("Daemon stopped after forcing remaining runtime processes");
-        return;
+        messages.push("Daemon stopped after forcing remaining runtime processes");
+        return { status: "stopped", messages };
+    }
+    messages.push("Daemon stopped");
+    return { status: "stopped", messages };
+}
+export async function cmdStop(_args) {
+    const outcome = await stopDaemonRuntimeForCli();
+    for (const message of outcome.messages) {
+        console.log(message);
     }
-    console.log("Daemon stopped");
+}
+export async function cmdRestart(stateManager, characterConfigManager, args) {
+    const stopOutcome = await stopDaemonRuntimeForCli();
+    for (const message of stopOutcome.messages) {
+        console.log(message);
+    }
+    if (stopOutcome.status === "failed") {
+        console.log("Daemon restart aborted; run `pulseed daemon status` to inspect the current state.");
+        return 1;
+    }
+    console.log("Starting daemon...");
+    await cmdStart(stateManager, characterConfigManager, args, {
+        childCommandArgs: ["daemon", "start", ...args],
+    });
+    return 0;
 }
 export async function cmdDaemonPing(_args) {
     const baseDir = getPulseedDirPath();
+    const schemaDriftMessage = formatControlDbSchemaDriftMessage(baseDir);
+    if (schemaDriftMessage) {
+        console.log(`Daemon ping failed: ${schemaDriftMessage}`);
+        return 1;
+    }
     const cfg = await loadDaemonConfig(baseDir);
     const port = cfg.event_server_port;
     const probe = await probeDaemonHealth({ host: "127.0.0.1", port });
@@ -683,7 +773,7 @@ export async function cmdDaemonPing(_args) {
         return 0;
     }
     const daemonInfo = await isDaemonRunning(baseDir);
-    const stateRaw = await readJsonFileOrNull(path.join(baseDir, "daemon-state.json"));
+    const stateRaw = await new DaemonStateStore(baseDir).load();
     const stateDetail = stateRaw && typeof stateRaw.status === "string"
         ? `, daemon state ${stateRaw.status}`
         : daemonInfo.running
@@ -710,15 +800,23 @@ export async function cmdCron(args) {
         values = {};
     }
     const goalIds = values.goal || [];
-    const intervalMinutes = parseInt(values.interval, 10) || 60;
+    let intervalMinutes;
+    try {
+        intervalMinutes = parseDaemonPositiveInteger(values.interval ?? "60", "--interval");
+    }
+    catch (err) {
+        getCliLogger().error(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
     if (goalIds.length === 0) {
         getCliLogger().error("Error: at least one --goal is required for pulseed cron.\nUsage: pulseed cron --goal <id> [--goal <id> ...]");
-        process.exit(1);
+        return 1;
     }
     console.log("# PulSeed crontab entries");
     console.log("# Add these to your crontab with: crontab -e");
     for (const goalId of goalIds) {
         console.log(DaemonRunner.generateCronEntry(goalId, intervalMinutes));
     }
+    return 0;
 }
 //# sourceMappingURL=daemon.js.map