@vibesdotdev/pm 0.0.0-stage → 1.0.0-rc.2

package/dist/client.js

@@ -0,0 +1,1005 @@
+/**
+ * PM Client
+ * Connects to PM daemon via the runtime-rpc-unix three-verb protocol
+ * (connectUnix + wireConsumer). The legacy HTTP-over-unix `pm-command` wire
+ * is gone; `rpc()` now routes through the RPC root the PM daemon exposes via
+ * `listenUnix`.
+ *
+ * Dates cross the wire as ISO strings, which are JSON-safe. The blanket
+ * dateReviver is still gone, but "parsed by callers that need Date objects"
+ * was not a workable contract: the methods below advertise `Date`-typed
+ * fields, nothing enforced that a caller parse them, and the first one that
+ * did not took a shipping command down (`vibes pm resource list` →
+ * "e.getTime is not a function", mid-table). So each reply is revived where
+ * its own shape is known — see `reviveResourceStatusDates` /
+ * `reviveResourceStateDates` — and the advertised type is the received type.
+ * Methods that return raw JSON keep returning raw JSON.
+ */
+import { getPathRoots, getRuntimePath } from '@vibesdotdev/paths';
+import * as z from 'zod/v4';
+import { BaseRuntimeClient } from '@vibesdotdev/kernel/client';
+import { runPmTaskOnClient } from "./tasks/run-task.js";
+import { AWAIT_EXIT_MAX_MS, AwaitExitOptionsSchema, pmTaskProcessIdentityOf } from "./schemas/process.js";
+import { DaemonShutdownReceiptSchema, DaemonHandoffReceiptSchema } from "./schemas/daemon.js";
+import { getPMSocketPath } from "./utils/socket-paths.js";
+import { getDaemonLaunchLockPath, guardDaemonLaunchChild, getPMDaemonLaunchLockTimeoutMs, isLaunchLockTimeoutError, LAUNCH_LOCK_TIMEOUT_REASON, readDaemonLaunchLockState, resolvePMDaemonStartTimeoutMs, withDaemonLaunchLock } from "./utils/daemon-launch-lock.js";
+import { bestEffortRecoverOrphanedGuard, describeRecoveryRefusal, tryRecoverOrphanedLaunchGuard } from "./utils/daemon-launch-recovery.js";
+import { getDaemonPidPath } from "./utils/daemon-pid.js";
+import { CapabilityError, CaughtFailureSchema, getRuntimeHostCommands, isCapabilityError } from '@vibesdotdev/kernel';
+import { connectUnix } from '@vibesdotdev/kernel-rpc/unix';
+import { wireConsumer, asRefId, RPC_ERROR } from '@vibesdotdev/kernel-rpc';
+import { createWorkerRuntimeRequest } from "./helpers/worker-routing.js";
+import { admittedWorkspaceIdentity, requireAdmittedWorkspace } from "./admission.js";
+import { composePMHostEnv } from "./helpers/process-env.js";
+import { isWaitTimeout, pollUntil } from "./utils/bounded-wait.js";
+import { PM_COMMAND_IDS } from "./daemon/command-ids.js";
+import { spawnDetachedDaemon } from "./cli/daemon-launch-child.js";
+import { removeSocket } from "./utils/socket.js";
+import { pmFileSystem } from "./helpers/runtime-files.js";
+import { attempt, attemptSync, failureLabel, failureText } from "./utils/attempt.js";
+import { hasErrno, rethrowFailure } from "./helpers/failure.js";
+import { AwaitExitReplySchema, SupervisedAdmissionReplySchema, SupervisedAcknowledgementReplySchema, ConfigReplySchema, ConfigsReplySchema, HealthReplySchema, IsRunningReplySchema, LivenessGetReplySchema, LivenessSetReplySchema, LogsReplySchema, LogsSinceReplySchema, OptionalProcessStateReplySchema, PresetStartReplySchema, PresetStopReplySchema, ProcessStateReplySchema, ProcessStatesReplySchema, ReconcileReplySchema, ResourceSetupReplySchema, ResourceStalenessReplySchema, ResourceStateReplySchema, ResourceStatesReplySchema, ResourceStatusReplySchema, RpcFailureSchema, RpcSuccessSchema, SocketStatusReplySchema, StartAllReplySchema, StartDeclaredReplySchema, UnregisterReplySchema, WorkersReadyReplySchema, parseReply } from "./client-replies.js";
+import { formatPMError, getPMDaemonLogger, getPMDaemonStderrLogPath, getPMDaemonStdoutLogPath } from "./utils/logging.js";
+/** Default timeout for RPC calls (60 seconds) */
+const DEFAULT_TIMEOUT_MS = 60000;
+/** How far an `await-exit` RPC's own deadline runs past the daemon's wait, as for a waited start. */
+const AWAIT_EXIT_RPC_MARGIN_MS = 5_000;
+/** The `await-exit` failure a lost daemon means: the run's exit could not be observed. */
+function awaitExitInterrupted(processId, cause) {
+    return new CapabilityError(`The PM daemon went away while awaiting '${processId}', and no daemon answered again.`, 'UNAVAILABLE', {
+        reason: 'pm-await-exit-interrupted',
+        retryable: true,
+        details: { processId },
+        cause
+    });
+}
+/**
+ * A dropped connection as `rpc()` surfaces it: the wire's `RPC_DISCONNECTED`
+ * failure, or, when the transport rejected with the bare envelope, the typed
+ * `pm-rpc-failed` that carries its code.
+ */
+const ConnectionLostSchema = z.union([
+    z.object({ code: z.literal(RPC_ERROR.DISCONNECTED) }),
+    z.object({ reason: z.literal('pm-rpc-failed'), details: z.object({ code: z.literal(RPC_ERROR.DISCONNECTED) }) })
+]);
+const NotAdvertisedSchema = z.object({ code: z.literal(RPC_ERROR.NOT_ADVERTISED) });
+const ShutdownInterruptSchema = z.object({ outcome: z.literal('interrupted'), cause: z.literal('shutdown') });
+/** An await-exit reply its daemon sent while shutting down: the call holds its connection until that daemon closes it. */
+function isShutdownInterrupt(reply) {
+    return ShutdownInterruptSchema.safeParse(reply).success;
+}
+/** Whether an RPC failed because its connection closed before a reply (`RPC_DISCONNECTED`): the daemon left mid-call. */
+function isConnectionLost(failure) {
+    return failure instanceof Error && ConnectionLostSchema.safeParse(failure).success;
+}
+/**
+ * The disk-I/O message with its target named: SQLite surfaces bare "disk I/O
+ * error" / SQLITE_IOERR with no target. Callers (ai ask, pm status, TUI)
+ * previously printed those three words as if the *client* disk had failed.
+ * Point at the PM daemon store + recovery. A message that is not a disk-I/O
+ * failure, or already names the daemon, is returned as it is.
+ */
+function localizeDaemonDiskIoMessage(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes('disk i/o error') ||
+        lower.includes('sqlite_ioerr') ||
+        lower.includes('disk i/o')) {
+        if (lower.includes('pm daemon') || lower.includes('vibes pm')) {
+            return message;
+        }
+        return (`PM daemon store I/O failure: ${message}. ` +
+            `Usually disk pressure or a stale daemon SQLite handle. ` +
+            `Check free space (df -h), then: vibes pm daemon restart. ` +
+            `If status still fails: vibes pm daemon stop && vibes pm daemon start.`);
+    }
+    return message;
+}
+/** A failure the wire threw as a plain value: its `message` or `error` text, and its `code`. */
+const WireFailureSchema = z.object({
+    message: z.string().min(1).optional(),
+    error: z.string().min(1).optional(),
+    code: z.string().min(1).optional()
+});
+/**
+ * An RPC failure as the caller sees it: the typed failure itself, or the same
+ * failure with the disk-I/O message localized (its code, reason and cause
+ * kept); a failure the wire threw as a plain value becomes a typed
+ * `INTERNAL pm-rpc-failed`.
+ */
+function normalizeRpcFailure(failure) {
+    if (failure instanceof Error) {
+        const localized = localizeDaemonDiskIoMessage(failure.message);
+        if (localized === failure.message)
+            return failure;
+        const typed = CapabilityError.from(failure);
+        return new CapabilityError(localized, typed.code, {
+            reason: typed.reason,
+            retryable: typed.retryable,
+            recoveryHint: typed.recoveryHint,
+            details: typed.details,
+            cause: failure
+        });
+    }
+    const wire = WireFailureSchema.safeParse(failure.value);
+    const message = wire.success ? (wire.data.message ?? wire.data.error) : undefined;
+    return new CapabilityError(localizeDaemonDiskIoMessage(message ?? failure.description), 'INTERNAL', {
+        reason: 'pm-rpc-failed',
+        details: wire.success && wire.data.code ? { code: wire.data.code } : undefined,
+        cause: failure
+    });
+}
+/** A failure's cause; none when it has none, or when reading it throws (a hostile getter). */
+function causeOf(failure) {
+    if (!(failure instanceof Error))
+        return undefined;
+    const read = attemptSync(() => failure.cause);
+    return read.ok && read.value !== undefined ? CaughtFailureSchema.parse(read.value) : undefined;
+}
+/**
+ * The confirmed-absence outcome of a daemon call: no daemon is listening at
+ * the socket. That is the transport's typed `UNAVAILABLE socket-unreachable`
+ * (an absent socket or a refused connect), or the raw errno it types
+ * (`ENOENT`, `ECONNREFUSED`) on an error or its cause. A message that merely
+ * mentions a code is not absence: a daemon relaying an `ENOENT` of its own
+ * answered, and that failure propagates.
+ */
+export function isDaemonUnavailableError(failure) {
+    let current = failure;
+    for (let depth = 0; current !== undefined && depth < 4; depth++) {
+        if (isCapabilityError(current))
+            return current.reason === 'socket-unreachable';
+        // Reading a hostile value (a throwing getter, a revoked Proxy) is not absence.
+        const holder = current instanceof Error ? current : current.value;
+        const read = attemptSync(() => ErrnoCodeSchema.safeParse(holder));
+        if (read.ok && read.value.success && (read.value.data.code === 'ENOENT' || read.value.data.code === 'ECONNREFUSED'))
+            return true;
+        current = causeOf(current);
+    }
+    return false;
+}
+const ErrnoCodeSchema = z.object({ code: z.string() });
+function rpcTimeoutForStart(options) {
+    if (!options?.wait)
+        return DEFAULT_TIMEOUT_MS;
+    const requested = options.timeout ?? DEFAULT_TIMEOUT_MS;
+    return Math.max(DEFAULT_TIMEOUT_MS, requested + 5_000);
+}
+function rpcTimeoutForPreset(options, fallbackMs) {
+    if (!options?.wait)
+        return fallbackMs;
+    const requested = options.timeout ?? DEFAULT_TIMEOUT_MS;
+    return Math.max(DEFAULT_TIMEOUT_MS, requested + 5_000);
+}
+export class PMClient extends BaseRuntimeClient {
+    /** Explicit, or computed from the admitted workspace on first use (see resolveSocketPath). */
+    socketPath;
+    usesDefaultSocket;
+    autoStartDaemon;
+    /**
+     * The workspace this client's daemon supervises: the explicit root, else
+     * the admitted workspace (framework-M8) of the runtime it resolves against,
+     * read on first use. Null until then.
+     */
+    workspaceIdentity;
+    /** The runtime the caller handed in: its admission names the daemon and its roots place every PM path. */
+    /** The roots every PM path joins under: injected, else `getPathRoots(runtime)`. */
+    roots;
+    /** Injected path mechanics (see constructor options.runtimePath); else resolved from `runtime` on first use. */
+    runtimePath;
+    constructor(socketPath, options, context) {
+        super({ id: 'pm', kind: 'runtime/client' }, context, options.runtime);
+        const explicitWorkspaceRoot = options.workspaceRoot?.trim();
+        this.workspaceIdentity = explicitWorkspaceRoot
+            ? admittedWorkspaceIdentity(explicitWorkspaceRoot)
+            : null;
+        this.usesDefaultSocket = !socketPath;
+        this.autoStartDaemon = options.autoStartDaemon ?? true;
+        this.roots = options.roots ?? getPathRoots(options.runtime);
+        this.runtimePath = options.runtimePath;
+        this.socketPath = socketPath || undefined;
+    }
+    /**
+     * The workspace this client's daemon supervises: the explicit root, else
+     * the admitted workspace of its runtime's binding. An unadmitted binding
+     * fails with `PERMISSION_DENIED` `workspace-not-admitted`, so nothing is
+     * ever started or addressed for a workspace PM was not admitted to.
+     */
+    async workspace() {
+        if (this.workspaceIdentity)
+            return this.workspaceIdentity;
+        const admitted = await requireAdmittedWorkspace(this.runtime);
+        this.workspaceIdentity = admittedWorkspaceIdentity(admitted.root);
+        return this.workspaceIdentity;
+    }
+    /** The daemon socket: explicit, or named by the admitted workspace on first use. */
+    async resolveSocketPath() {
+        if (this.socketPath === undefined) {
+            const workspace = await this.workspace();
+            this.socketPath = getPMSocketPath(workspace.workspacePath, {
+                roots: this.roots,
+                runtimePath: this.runtimePath ?? (await getRuntimePath(this.runtime))
+            });
+        }
+        return this.socketPath;
+    }
+    // Daemon Lifecycle Management
+    /**
+     * Check if daemon is running and reachable
+     */
+    async isDaemonRunning(timeoutMs) {
+        const { isDaemonReachable } = await import("./utils/daemon-reachability.js");
+        return isDaemonReachable(this.runtime, timeoutMs ?? 250, await this.resolveSocketPath());
+    }
+    /**
+     * Reads the current launch-lock without acquiring, reclaiming, or waiting
+     * on it, through the runtime's filesystem and process service, resolving
+     * the workspace first. Read-only status surfaces use this when no daemon
+     * is reachable.
+     */
+    async readDaemonLaunchLockState() {
+        const { toolingId } = await this.workspace();
+        return readDaemonLaunchLockState(this.runtime, getDaemonLaunchLockPath(toolingId, await this.pathOptions()));
+    }
+    /** The roots and path mechanics every PM path of this client joins under. */
+    async pathOptions() {
+        return { roots: this.roots, runtimePath: this.runtimePath ?? (await getRuntimePath(this.runtime)) };
+    }
+    /**
+     * Attempt to start the daemon
+     * @returns true if daemon started successfully or was already running
+     * @throws CapabilityError if the daemon fails to start
+     */
+    async attemptStartDaemon(options = {}) {
+        const { isDaemonReachable } = await import("./utils/daemon-reachability.js");
+        const { toolingId, workspacePath: workspaceRoot } = await this.workspace();
+        // Check if already running before acquiring lock
+        if (await isDaemonReachable(this.runtime, 1000, await this.resolveSocketPath())) {
+            return true;
+        }
+        // Use a lock file to serialize daemon launches
+        // This prevents multiple clients from spawning daemons simultaneously
+        const pathOptions = await this.pathOptions();
+        const lockFile = getDaemonLaunchLockPath(toolingId, pathOptions);
+        // C15: the daemon launch carries PM's base set and the host's re-entry
+        // facts and roots, from the handed runtime alone.
+        const daemonEnv = composePMHostEnv(this.runtime);
+        // Env knob read from the handed runtime's snapshot (RC04 moves it to a manifest key).
+        const startTimeoutMs = resolvePMDaemonStartTimeoutMs(this.runtime.getEnvSnapshot().VIBES_PM_DAEMON_START_TIMEOUT_MS);
+        const launch = async (lease) => {
+            // Double-check: maybe another process started it while we waited
+            if (await isDaemonReachable(this.runtime, 1000, await this.resolveSocketPath())) {
+                return true;
+            }
+            await this.cleanupStaleDaemonArtifacts();
+            // Launching this workspace's daemon never signals another workspace's
+            // (pm.md D3): strays are reported by `vibes pm daemon reconcile`.
+            if (await isDaemonReachable(this.runtime, 1000, await this.resolveSocketPath())) {
+                return true;
+            }
+            const stdoutPath = getPMDaemonStdoutLogPath(workspaceRoot, pathOptions);
+            const stderrPath = getPMDaemonStderrLogPath(workspaceRoot, pathOptions);
+            await (await pmFileSystem(this.runtime)).mkdir(pathOptions.runtimePath.dirname(stdoutPath), { recursive: true });
+            // Re-enter only through the handed runtime's declared host command
+            // shape (`runtime/host-command`; compiled and source hosts both declare
+            // it) or the embedding host's resolved argv. The launch's shape is
+            // `daemon-launch-child.ts`'s: a daemon launch, so PM is never this
+            // process's descendant, with `--detached` (stdout/stderr are the log
+            // files above, so serve's orphaned-stdio guard does not refuse under a
+            // non-TTY caller; without it every agent's `vibes pm daemon restart`
+            // stopped the daemon and failed to start one, measured 2026-08-28), the
+            // admitted root in argv (never an env var, rc02-rc03 §2.2) and
+            // RLIMIT_NOFILE raised for the whole tree the daemon spawns.
+            const hostArgv = options.selfSpawnArgv?.length
+                ? options.selfSpawnArgv
+                : (await getRuntimeHostCommands(this.runtime)).selfSpawnArgv('PM daemon');
+            lease.preserveOnFailure = true;
+            const spawned = await attempt(() => spawnDetachedDaemon(this.runtime, { hostArgv, workspaceRoot, env: daemonEnv, stdoutPath, stderrPath }));
+            if (!spawned.ok) {
+                // Rejection is not an exit receipt: the provider or supervision
+                // wrapper may fail after starting a child but before handing it over.
+                throw new CapabilityError('The daemon launch outcome is unknown; launch custody is retained', 'INTERNAL', {
+                    reason: 'pm-daemon-launch-outcome-unknown', cause: spawned.failure,
+                    recoveryHint: 'Inspect readDaemonLaunchLockState(). The originating owner may release the exact lease only after proving no child was started or observing its exit. Otherwise the next launch recovers the orphaned guard itself once its launcher is gone, or run `vibes pm daemon recover`.'
+                });
+            }
+            const proc = spawned.value;
+            const started = await attempt(async () => {
+                if (proc.pid === undefined) {
+                    throw new CapabilityError('The daemon launch returned no child pid', 'INTERNAL', {
+                        reason: 'pm-daemon-launch-no-pid',
+                        details: { workspace: workspaceRoot }
+                    });
+                }
+                await guardDaemonLaunchChild(lease, proc.pid);
+                const healthTimeoutMs = 1000;
+                // Wait for the daemon's socket to answer, bounded by the runtime
+                // lifecycle (RC07). Poll: the daemon (owner) publishes no
+                // cross-process readiness event; a child that exited ends the wait.
+                let exitedEarly = false;
+                const reachable = await pollUntil(this.runtime, async () => {
+                    if (await isDaemonReachable(this.runtime, healthTimeoutMs, await this.resolveSocketPath())) {
+                        return true;
+                    }
+                    if (proc.exitCode !== null) {
+                        exitedEarly = true;
+                        return true;
+                    }
+                    return false;
+                }, { timeoutMs: startTimeoutMs, intervalMs: 100, reason: 'pm-daemon-ready' });
+                if (reachable && !exitedEarly) {
+                    proc.unref();
+                    return true;
+                }
+                if (exitedEarly && (await isDaemonReachable(this.runtime, healthTimeoutMs, await this.resolveSocketPath()))) {
+                    return true;
+                }
+                // If we reach here, daemon failed to start
+                let errorDetails = '';
+                if (proc.exitCode !== null) {
+                    // A daemon is not this process's child: its exit code never reaches the launcher.
+                    errorDetails = 'Daemon process exited before its socket answered.';
+                }
+                const tail = await attempt(async () => {
+                    const { readPMDaemonLogTail } = await import("./utils/logging.js");
+                    return readPMDaemonLogTail(this.runtime, 20);
+                });
+                // The start failure below stays the error; an unreadable log is reported beside it, as its cause.
+                let logReadFailure;
+                if (tail.ok) {
+                    if (tail.value.length > 0)
+                        errorDetails = tail.value.join('\n');
+                }
+                else {
+                    logReadFailure = tail.failure;
+                    getPMDaemonLogger(this.runtime).warn('Failed to read PM daemon log tail', formatPMError(tail.failure));
+                }
+                if (!errorDetails.trim() && proc.exitCode === null) {
+                    errorDetails = `Daemon did not become reachable within ${startTimeoutMs}ms.`;
+                }
+                throw new CapabilityError(errorDetails.trim()
+                    ? `Failed to start PM daemon. Recent logs:\n${errorDetails}`
+                    : 'Failed to start PM daemon (no error details available)', 'UNAVAILABLE', { reason: 'pm-daemon-start-failed', details: { workspace: workspaceRoot }, cause: logReadFailure });
+            });
+            if (started.ok)
+                return started.value;
+            // This launch owns the child handle. Never release launch custody
+            // while our failed startup can still become another daemon.
+            const reaped = await attempt(async () => {
+                await this.reapFailedDaemonLaunch(proc);
+                lease.preserveOnFailure = false;
+            });
+            if (!reaped.ok) {
+                throw new CapabilityError('The failed PM daemon launch could not be reaped.', 'INTERNAL', {
+                    reason: 'pm-daemon-launch-cleanup-failed',
+                    details: { pid: proc.pid, workspace: workspaceRoot },
+                    recoveryHint: 'Launch custody is retained. Inspect readDaemonLaunchLockState(); the originating owner may release its exact lease only after proving its child exited. Once the child has exited, the next launch reclaims its guard; `vibes pm daemon recover` reports the guard state without touching live custody.',
+                    cause: new AggregateError([started.failure, reaped.failure], 'PM daemon startup and cleanup failed')
+                });
+            }
+            return rethrowFailure(started.failure);
+        };
+        const lockTimeoutMs = getPMDaemonLaunchLockTimeoutMs(startTimeoutMs);
+        const guardProbe = {
+            lockFile,
+            socketPath: await this.resolveSocketPath(),
+            pidFile: getDaemonPidPath(toolingId, pathOptions),
+            startTimeoutMs
+        };
+        // Best-effort pre-pass: an ancient orphan must not cost a full acquire
+        // timeout. It never throws and never blocks the launch below.
+        await bestEffortRecoverOrphanedGuard(this.runtime, guardProbe);
+        const launched = await attempt(() => withDaemonLaunchLock(this.runtime, lockFile, lockTimeoutMs, launch, { unresolvedLaunch: true }));
+        if (launched.ok)
+            return launched.value;
+        // A launch blocked only by a dead launcher's orphaned guard heals
+        // here: prove absence, clear it, launch once. Any other timeout
+        // keeps its error, with the guard's verdict beside it.
+        if (!isLaunchLockTimeoutError(launched.failure))
+            return rethrowFailure(launched.failure);
+        const timeoutMessage = failureText(launched.failure);
+        const recovery = await attempt(() => tryRecoverOrphanedLaunchGuard(this.runtime, guardProbe));
+        if (!recovery.ok) {
+            throw new CapabilityError(`${timeoutMessage}; orphan-guard probe failed (${failureLabel(recovery.failure)})`, 'TIMEOUT', {
+                reason: LAUNCH_LOCK_TIMEOUT_REASON,
+                retryable: true,
+                details: { lockFile },
+                cause: new AggregateError([launched.failure, recovery.failure], 'The launch lock timed out and its orphan-guard probe failed')
+            });
+        }
+        if (!recovery.value.recovered) {
+            throw new CapabilityError(`${timeoutMessage}; ${describeRecoveryRefusal(recovery.value)}. ` +
+                "Run 'vibes pm daemon recover' to re-check.", 'TIMEOUT', { reason: LAUNCH_LOCK_TIMEOUT_REASON, retryable: true, details: { lockFile, recoveryRefusal: recovery.value.reason }, cause: launched.failure });
+        }
+        getPMDaemonLogger(this.runtime).warn('recovered orphaned launch guard during auto-start; retrying launch', {
+            lockFile
+        });
+        return await withDaemonLaunchLock(this.runtime, lockFile, lockTimeoutMs, launch, {
+            unresolvedLaunch: true
+        });
+    }
+    /** Signal only the child this launch owns, and observe its exit before releasing the lease. */
+    async reapFailedDaemonLaunch(proc) {
+        if (proc.exitCode !== null)
+            return;
+        await proc.kill('SIGTERM');
+        // The handle publishes exit through exitCode, not an exit promise.
+        // Poll that owned handle under the runtime lifecycle, never a guessed pid.
+        if (await pollUntil(this.runtime, async () => proc.exitCode !== null, {
+            timeoutMs: 2000, intervalMs: 50, reason: 'pm-daemon-launch-exit'
+        }))
+            return;
+        await proc.kill('SIGKILL');
+        if (!(await pollUntil(this.runtime, async () => proc.exitCode !== null, {
+            timeoutMs: 3000, intervalMs: 50, reason: 'pm-daemon-launch-exit'
+        }))) {
+            throw new CapabilityError('The launched PM daemon did not exit after termination.', 'TIMEOUT', {
+                reason: 'pm-daemon-launch-survived', details: { pid: proc.pid }
+            });
+        }
+    }
+    async cleanupStaleDaemonArtifacts() {
+        const [{ getDaemonPidPath, readDaemonPid }, { isDaemonReachable }] = await Promise.all([
+            import("./utils/daemon-pid.js"),
+            import("./utils/daemon-reachability.js")
+        ]);
+        const pidFile = getDaemonPidPath((await this.workspace()).toolingId, await this.pathOptions());
+        const pid = await readDaemonPid(this.runtime, pidFile);
+        const reachable = await isDaemonReachable(this.runtime, 750, await this.resolveSocketPath());
+        if (pid !== null && !reachable) {
+            // A timeout is not absence. Neither pid-file age nor argv resemblance
+            // authorizes disconnecting a live incumbent from its identity.
+            throw new CapabilityError('The recorded PM daemon is alive but its socket did not answer.', 'UNAVAILABLE', {
+                reason: 'pm-daemon-unreachable',
+                details: { pid, workspace: (await this.workspace()).workspacePath },
+                recoveryHint: 'Inspect the daemon logs and restart it through its owning PM daemon.'
+            });
+        }
+        if (pid === null && !reachable) {
+            // Native socket ownership is stricter than the RPC handshake: a live
+            // listener with no pid file must not be unlinked either.
+            await removeSocket(this.runtime, await this.resolveSocketPath());
+            await this.removeFileIfPresent(pidFile);
+        }
+    }
+    /** Remove `path`; an already-absent file (`ENOENT`) is the goal, any other failure propagates. */
+    async removeFileIfPresent(path) {
+        const files = await pmFileSystem(this.runtime);
+        const removed = await attempt(() => files.remove(path));
+        if (!removed.ok && !hasErrno(removed.failure, 'ENOENT'))
+            rethrowFailure(removed.failure);
+    }
+    /**
+     * Ensure daemon is running (check, attempt, fail with useful error)
+     */
+    async ensureDaemonRunning(options = {}) {
+        await this.attemptStartDaemon(options);
+    }
+    /**
+     * A read: the same RPC, but it never starts the daemon. Status, logs and
+     * config lookups report that the daemon is not running instead of spawning
+     * one, so running a read command anywhere has no side effects.
+     */
+    read(command, params = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        return this.rpc(command, params, timeoutMs, false);
+    }
+    /** An RPC whose reply is read through `schema` where it arrives. */
+    async callReply(schema, command, params = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        return parseReply(command, schema, await this.rpc(command, params, timeoutMs));
+    }
+    /** A read whose reply is read through `schema` where it arrives. */
+    async readReply(schema, command, params = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        return parseReply(command, schema, await this.read(command, params, timeoutMs));
+    }
+    /**
+     * Make an RPC call to the PM daemon via the runtime-rpc-unix three-verb
+     * protocol. Each call opens a connection, invokes one method on the PM
+     * RPC root (the method name IS the command name), and closes. The legacy
+     * HTTP `fetch('http://pm/rpc', { unix })` + `dateReviver` envelope is gone.
+     */
+    async rpc(command, params = {}, timeoutMs = DEFAULT_TIMEOUT_MS, startDaemon = true, callerSignal, 
+    /**
+     * Whether `reply` asks this call to keep its connection until the
+     * daemon that sent it closes it (a shutdown reply: the daemon closes
+     * every session when its listener stops). Bounded by the call's deadline.
+     */
+    holdUntilClosed) {
+        // One lifecycle-bounded wait (RC07): the RPC's deadline, and the runtime's
+        // disposal, abort it; the abort closes the connection it opened.
+        const invoke = async (signal) => {
+            const socketPath = await this.resolveSocketPath();
+            const connectTimeoutMs = Math.min(timeoutMs, DEFAULT_TIMEOUT_MS);
+            const dialOnce = () => attempt(() => connectUnix(socketPath, { runtime: this.runtime, timeoutMs: connectTimeoutMs, signal }));
+            let connected = await dialOnce();
+            // Auto-start the daemon on the default socket only when no daemon is
+            // listening there (`socket-unreachable`), never before every call.
+            if (!connected.ok &&
+                startDaemon &&
+                this.usesDefaultSocket &&
+                this.autoStartDaemon &&
+                isDaemonUnavailableError(connected.failure)) {
+                await this.ensureDaemonRunning();
+                connected = await dialOnce();
+            }
+            for (let retry = 0; !connected.ok &&
+                retry < 3 &&
+                !signal.aborted &&
+                isCapabilityError(connected.failure) &&
+                (connected.failure.reason === 'rpc-handshake-timeout' ||
+                    connected.failure.reason === 'socket-connect-timeout' ||
+                    connected.failure.reason === 'rpc-handshake-closed'); retry++) {
+                await this.runtime.lifecycle.delay(250 * (retry + 1), signal);
+                if (signal.aborted)
+                    break;
+                connected = await dialOnce();
+            }
+            if (!connected.ok)
+                return rethrowFailure(connected.failure);
+            const connection = connected.value;
+            const closeOnAbort = () => {
+                void attempt(() => connection.close()).then((closed) => {
+                    if (closed.ok)
+                        return;
+                    getPMDaemonLogger(this.runtime).warn('PM RPC connection close after abort failed', {
+                        command,
+                        ...formatPMError(closed.failure)
+                    });
+                });
+            };
+            signal.addEventListener('abort', closeOnAbort, { once: true });
+            try {
+                const { root } = wireConsumer({
+                    // The PM root's methods are its stable wire commands (C19).
+                    rootMethods: PM_COMMAND_IDS,
+                    rootRef: connection.rootRef,
+                    send: (req) => connection.send(req),
+                    openStream: (ref, channel) => connection.openStream(asRefId(ref), channel),
+                    closed: connection.closed
+                });
+                const served = z.custom((value) => z.object({ [command]: z.function() }).safeParse(value).success).safeParse(root);
+                if (!served.success) {
+                    throw new CapabilityError(`PM daemon has no RPC method '${command}'`, 'UNAVAILABLE', {
+                        reason: 'pm-daemon-method-missing',
+                        retryable: false,
+                        details: { command }
+                    });
+                }
+                const result = await served.data[command](params);
+                const success = RpcSuccessSchema.safeParse(result);
+                if (!success.success) {
+                    const failure = RpcFailureSchema.safeParse(result);
+                    throw new CapabilityError(failure.success ? failure.data.error : `Command failed: ${command}`, 'INTERNAL', {
+                        reason: 'pm-daemon-command-failed',
+                        details: { command }
+                    });
+                }
+                if (holdUntilClosed?.(success.data))
+                    await connection.closed;
+                return success.data;
+            }
+            finally {
+                signal.removeEventListener('abort', closeOnAbort);
+                await connection.close();
+            }
+        };
+        // A caller's signal joins the wait: its abort closes the connection,
+        // which ends the daemon's work for it (runtime-rpc rule 19).
+        const waited = await attempt(() => this.runtime.lifecycle.wait(invoke, callerSignal ? { timeoutMs, reason: `pm-rpc:${command}`, signal: callerSignal } : { timeoutMs, reason: `pm-rpc:${command}` }));
+        if (waited.ok)
+            return waited.value;
+        // A daemon from an older build does not serve this command: it is not
+        // advertised on its root. That is a missing method, typed, never a fallback.
+        if (waited.failure instanceof Error && NotAdvertisedSchema.safeParse(waited.failure).success) {
+            throw new CapabilityError(`PM daemon has no RPC method '${command}'`, 'UNAVAILABLE', {
+                reason: 'pm-daemon-method-missing',
+                retryable: false,
+                details: { command },
+                recoveryHint: "Restart the PM daemon from the current CLI: 'vibes pm daemon restart'."
+            });
+        }
+        throw normalizeRpcFailure(waited.failure);
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Process Management
+    // ─────────────────────────────────────────────────────────────────────────────
+    async start(config, options) {
+        const { state } = await this.callReply(ProcessStateReplySchema, 'start', { config, options }, rpcTimeoutForStart(options));
+        return state;
+    }
+    async stop(processId, options) {
+        await this.rpc('stop', { processId, options });
+    }
+    /**
+     * Restart a managed process. `guard.expectedPid` lets a body that asks to
+     * be rolled prove it IS the process the daemon tracks under `processId`;
+     * the daemon refuses when the tracked pid differs. Measured 2026-09-05: an
+     * orphan carrying an inherited VIBES_PM_MANAGED stamp rolled the healthy
+     * shared MCP host every five minutes (552 of 586 restarts).
+     */
+    async restart(processId, options, guard) {
+        const params = { processId, options };
+        if (guard?.expectedPid !== undefined)
+            params.expectedPid = guard.expectedPid;
+        const { state } = await this.callReply(ProcessStateReplySchema, 'restart', params, rpcTimeoutForStart(options));
+        return state;
+    }
+    /**
+     * The daemon's health, or `null` when no daemon is listening (its socket
+     * missing or refusing: the confirmed-absence codes). Any other failure,
+     * a timeout from a daemon that accepted the call included, propagates.
+     * The default 1 s suits a liveness probe; work that must wait for a busy
+     * daemon passes a longer `timeoutMs`.
+     */
+    async health(timeoutMs = 1000) {
+        const read = await attempt(() => this.readReply(HealthReplySchema, 'health', {}, timeoutMs));
+        if (read.ok)
+            return read.value.health;
+        if (isDaemonUnavailableError(read.failure))
+            return null;
+        return rethrowFailure(read.failure);
+    }
+    async reconcileState() {
+        const { summary } = await this.callReply(ReconcileReplySchema, 'reconcile');
+        return summary;
+    }
+    /**
+     * Ask the daemon to perform its own orderly shutdown.
+     *
+     * This is intentionally an RPC instead of a caller-side signal: the daemon
+     * is the only owner that can drain managed children, persist their stopped
+     * state, and remove its socket/PID artifacts coherently.
+     */
+    async shutdownDaemon() {
+        return this.callReply(DaemonShutdownReceiptSchema, 'shutdown', {}, 2_000);
+    }
+    /** Release the serving daemon while preserving its tracked managed runs. */
+    async handoffDaemon() {
+        return this.callReply(DaemonHandoffReceiptSchema, 'handoff', {}, 2_000);
+    }
+    async getStatus(processId) {
+        const { state } = await this.readReply(OptionalProcessStateReplySchema, 'status', { processId });
+        return state ?? undefined;
+    }
+    async getAllStatus() {
+        const read = await attempt(() => this.readReply(ProcessStatesReplySchema, 'status-all'));
+        if (read.ok)
+            return read.value.states;
+        if (isDaemonUnavailableError(read.failure))
+            return [];
+        return rethrowFailure(read.failure);
+    }
+    async isRunning(processId) {
+        const { isRunning } = await this.readReply(IsRunningReplySchema, 'is-running', { processId });
+        return isRunning;
+    }
+    /**
+     * Await a run's exit through the daemon's `await-exit`: one RPC that ends
+     * on the exit (never a status poll). `run` names the run; absent, the run
+     * current now is read once and pinned, so a re-issue never latches onto a
+     * later run. The deadline is the caller's (default the host timer ceiling
+     * less the RPC margin); the caller's signal closes the connection.
+     *
+     * Re-issue: when the daemon answers `interrupted` (a new host generation,
+     * or shutdown) or the connection drops before a reply, the same
+     * `{ processId, run }` is sent again within the remaining deadline. Each
+     * re-issue follows a daemon event, never a timer: after a shutdown the
+     * client first awaits the old daemon closing its connection, then goes
+     * through the launch-lock-serialized `ensureDaemonRunning` (auto-start
+     * clients). A re-issue no daemon answers refuses `UNAVAILABLE`
+     * `pm-await-exit-interrupted`.
+     */
+    async awaitExit(processId, options = {}) {
+        const parsed = AwaitExitOptionsSchema.safeParse({ run: options.run, timeoutMs: options.timeoutMs });
+        if (!parsed.success) {
+            throw new CapabilityError('awaitExit received invalid options.', 'INVALID_INPUT', {
+                reason: 'pm-await-exit-options-invalid',
+                details: { processId, fields: [...new Set(parsed.error.issues.map((issue) => issue.path.join('.') || '(options)'))] }
+            });
+        }
+        const { signal } = options;
+        const budgetMs = parsed.data.timeoutMs ?? AWAIT_EXIT_MAX_MS - AWAIT_EXIT_RPC_MARGIN_MS;
+        const deadline = this.runtime.lifecycle.now() + budgetMs;
+        const remaining = () => {
+            const left = Math.floor(deadline - this.runtime.lifecycle.now());
+            if (left >= 1)
+                return left;
+            throw new CapabilityError(`Process '${processId}' did not exit within ${budgetMs}ms.`, 'TIMEOUT', {
+                reason: 'pm-await-exit-timeout',
+                retryable: true,
+                details: { processId, timeoutMs: budgetMs }
+            });
+        };
+        const run = parsed.data.run ?? (await this.currentRun(processId));
+        let reissue = false;
+        for (;;) {
+            if (reissue && this.usesDefaultSocket && this.autoStartDaemon)
+                await this.ensureDaemonRunning();
+            const timeoutMs = remaining();
+            const params = run ? { processId, run, timeoutMs } : { processId, timeoutMs };
+            const replied = await attempt(() => this.rpc('await-exit', params, Math.min(AWAIT_EXIT_MAX_MS, timeoutMs + AWAIT_EXIT_RPC_MARGIN_MS), false, signal, isShutdownInterrupt));
+            if (!replied.ok) {
+                if (signal?.aborted)
+                    return rethrowFailure(replied.failure);
+                if (isConnectionLost(replied.failure)) {
+                    reissue = true;
+                    continue;
+                }
+                if (reissue && isDaemonUnavailableError(replied.failure))
+                    throw awaitExitInterrupted(processId, replied.failure);
+                if (isWaitTimeout(replied.failure))
+                    remaining();
+                return rethrowFailure(replied.failure);
+            }
+            const reply = parseReply('await-exit', AwaitExitReplySchema, replied.value);
+            switch (reply.outcome) {
+                case 'exited':
+                    return reply.exit;
+                case 'deadline':
+                    throw new CapabilityError(`Process '${processId}' did not exit within ${budgetMs}ms.`, 'TIMEOUT', {
+                        reason: 'pm-await-exit-timeout',
+                        retryable: true,
+                        details: { processId, timeoutMs: budgetMs }
+                    });
+                case 'absent':
+                    throw new CapabilityError(`Process '${processId}' has no state to await.`, 'NOT_FOUND', {
+                        reason: 'pm-process-state-not-found',
+                        details: { processId }
+                    });
+                case 'superseded':
+                    throw new CapabilityError(`Process '${processId}' started a later run before the awaited one exited.`, 'CONFLICT', {
+                        reason: 'pm-await-exit-run-superseded',
+                        details: { processId }
+                    });
+                case 'interrupted':
+                    // A shutdown reply returned only once its own daemon closed the
+                    // connection (`isShutdownInterrupt`): the re-issue reaches its successor.
+                    reissue = true;
+            }
+        }
+    }
+    /** The run `processId` is on now, read once; no state refuses `NOT_FOUND` `pm-process-state-not-found`. */
+    async currentRun(processId) {
+        const state = await this.getStatus(processId);
+        if (!state) {
+            throw new CapabilityError(`Process '${processId}' has no state to await.`, 'NOT_FOUND', {
+                reason: 'pm-process-state-not-found',
+                details: { processId }
+            });
+        }
+        return state.startedAt ? { startedAt: state.startedAt } : undefined;
+    }
+    async getLogs(processId, options) {
+        const { logs } = await this.readReply(LogsReplySchema, 'logs', { processId, options });
+        return logs;
+    }
+    /** What `processId`'s logs gained since `offsets`, complete lines only, redacted by the daemon (RC05). */
+    async getLogsSince(processId, offsets) {
+        return this.readReply(LogsSinceReplySchema, 'logs-since', { processId, offsets });
+    }
+    async register(config) {
+        await this.rpc('register', { config });
+    }
+    async unregister(processId) {
+        const { unregistered } = await this.callReply(UnregisterReplySchema, 'unregister', { processId });
+        return unregistered;
+    }
+    /** Ordinary tasks on the client the caller already selected. */
+    async runTask(task, options) {
+        return runPmTaskOnClient(this, task, options);
+    }
+    /** Local owner capability: terminal acknowledgement is awaited before ephemeral task release. */
+    async runSupervisedTask(task, options) {
+        const scope = await this.taskSupervisionScope();
+        return runPmTaskOnClient(this, task, options, {
+            scope, admissionId: crypto.randomUUID(), callbacks: options.supervision
+        });
+    }
+    async admitSupervisedTask(identity, task, options) {
+        const timeoutMs = 'processId' in task ? rpcTimeoutForPreset(undefined, 30 * 60_000) : rpcTimeoutForStart();
+        const reply = await this.rpc('admit-task', {
+            identity: pmTaskProcessIdentityOf(identity), task, runId: options.runId, tags: options.tags ?? []
+        }, timeoutMs, true, options.signal);
+        const { state } = parseReply('admit-task', ProcessStateReplySchema, reply);
+        return state;
+    }
+    async supervisedAdmission(identity) {
+        const { admission } = await this.readReply(SupervisedAdmissionReplySchema, 'task-admission', { identity: pmTaskProcessIdentityOf(identity) });
+        return admission;
+    }
+    async acknowledgeSupervised(receipt) {
+        const { acknowledged } = await this.callReply(SupervisedAcknowledgementReplySchema, 'acknowledge-task', { receipt });
+        return acknowledged;
+    }
+    async taskSupervisionScope() {
+        const expected = await this.workspace();
+        // Admission waits as long as any other PM read: health()'s 1 s liveness cap
+        // failed whole check and publish graphs while the daemon was busy admitting
+        // their siblings (2026-10-27: 62 of 82 packages skipped in one publish).
+        const health = await this.health(DEFAULT_TIMEOUT_MS);
+        const scope = health?.healthy ? health.taskSupervision?.scope : undefined;
+        if (!scope || scope.workspacePath !== expected.workspacePath || scope.toolingId !== expected.toolingId) {
+            throw new CapabilityError('The selected PM daemon cannot preserve supervised task settlement in this scope.', 'UNAVAILABLE', {
+                reason: 'pm-task-supervision-unavailable', retryable: false
+            });
+        }
+        return scope;
+    }
+    async getConfig(processId) {
+        const { config } = await this.readReply(ConfigReplySchema, 'get-config', { processId });
+        return config ?? undefined;
+    }
+    async getAllConfigs() {
+        const { configs } = await this.readReply(ConfigsReplySchema, 'get-all-configs');
+        return configs;
+    }
+    async touch(processId, timestamp) {
+        const payload = timestamp instanceof Date ? timestamp.toISOString() : timestamp;
+        await this.rpc('touch', { processId, timestamp: payload });
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Liveness / Presence Profiles (pm-infra-liveness-fleet Phase 2)
+    // Reusable targeting + active profile surface. Concrete fleet proxy / remote
+    // activation can be driven from instance providers (pm/fleet/*) or daemon extensions.
+    // Per SPEC §CLI/manager (for changes here): " - **CLI** (`src/cli/`): ... " + "Does not own" pm/ workspace data.
+    // set now returns the handler result (incl. proxy after materialization) for --json in liveness set impl.
+    // get unwraps but augments active with proxy info from liveness-get reply (for list --env surface).
+    // ─────────────────────────────────────────────────────────────────────────────
+    async setLivenessProfile(profile, options) {
+        return this.callReply(LivenessSetReplySchema, 'liveness-set', { profile, ...options });
+    }
+    async getActiveLivenessProfile(options) {
+        const { active, proxy } = await this.readReply(LivenessGetReplySchema, 'liveness-get', { ...options });
+        if (!active)
+            return undefined;
+        // If top-level proxy present in reply (from get), surface it on the active shape too for callers.
+        if (proxy && !active.proxy) {
+            return { ...active, proxy };
+        }
+        return active;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Resource Management
+    // ─────────────────────────────────────────────────────────────────────────────
+    async setupResource(config, options) {
+        // Extended timeout for resource setup (resources can take time to become ready)
+        const timeoutMs = Math.max(120000, (config.readyTimeout || 60000) + 30000);
+        const { result } = await this.callReply(ResourceSetupReplySchema, 'resource-setup', { config, options: options ?? {} }, timeoutMs);
+        return result;
+    }
+    /**
+     * Set up a declared resource by id: the daemon resolves its config against
+     * its own graph (pm.md C1). Same budget as {@link setupResource}'s floor.
+     */
+    async setupDeclaredResource(resourceId, options, readyTimeoutMs = 60000) {
+        const timeoutMs = Math.max(120000, readyTimeoutMs + 30000);
+        const { result } = await this.callReply(ResourceSetupReplySchema, 'resource-setup', { resourceId, options: options ?? {} }, timeoutMs);
+        return result;
+    }
+    async stopResource(resourceId) {
+        const state = await this.getResourceState(resourceId);
+        await this.rpc('resource-stop', { resourceId, state });
+    }
+    async resumeResource(resourceId) {
+        const state = await this.getResourceState(resourceId);
+        await this.rpc('resource-resume', { resourceId, state });
+    }
+    async restartResource(resourceId) {
+        const state = await this.getResourceState(resourceId);
+        await this.rpc('resource-restart', { resourceId, state });
+    }
+    async teardownResource(resourceId) {
+        const state = await this.getResourceState(resourceId);
+        await this.rpc('resource-teardown', { resourceId, state });
+    }
+    async getResourceStatus(resourceId, options, config) {
+        const { status } = await this.readReply(ResourceStatusReplySchema, 'resource-status', {
+            resourceId,
+            options: options ?? {},
+            config
+        });
+        return status;
+    }
+    async checkResourceStaleness(config) {
+        return this.readReply(ResourceStalenessReplySchema, 'resource-check-staleness', { config });
+    }
+    async getResourceState(resourceId) {
+        const { state } = await this.readReply(ResourceStateReplySchema, 'resource-get-state', { resourceId });
+        return state ?? undefined;
+    }
+    async getAllResourceStates() {
+        const { states } = await this.readReply(ResourceStatesReplySchema, 'resource-get-all-states');
+        return states;
+    }
+    async getAllResourceStateSummaries() {
+        const states = await this.getAllResourceStates();
+        const { summarizeResourceState } = await import("./resources/resource-state-summary.js");
+        return states.map((state) => summarizeResourceState(state));
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Preset Management
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Start a declared preset by id. The daemon resolves it against its own
+     * graph (pm.md C1): the client sends the id, never a config.
+     *
+     * Preset starts can take a while when maxProcessConcurrency serializes warmup:
+     * each process holds its semaphore slot until it reports healthy (warmupMs
+     * budget is up to ~2.5min per app). A 15-app preset at concurrency 2 can take
+     * 20+ minutes end-to-end; budget 30min so the CLI doesn't abort the RPC.
+     */
+    async startPreset(presetId, options) {
+        const { result } = await this.callReply(PresetStartReplySchema, 'preset-start', { presetId, options }, rpcTimeoutForPreset(options, 30 * 60_000));
+        return result;
+    }
+    /** Stop a declared preset by id. Stops are teardown-only and fast; 5min covers large presets. */
+    async stopPreset(presetId) {
+        const { result } = await this.callReply(PresetStopReplySchema, 'preset-stop', { presetId }, 5 * 60_000);
+        return result;
+    }
+    /** Restart a declared preset by id: stop, then the long start (see startPreset). */
+    async restartPreset(presetId, options) {
+        const { result } = await this.callReply(PresetStartReplySchema, 'preset-restart', { presetId, options }, rpcTimeoutForPreset(options, 35 * 60_000));
+        return result;
+    }
+    /**
+     * Tear down a declared preset by id (destructive: processes and resources).
+     * Resources like kind clusters can take minutes to delete; 10min covers it.
+     */
+    async teardownPreset(presetId) {
+        const { result } = await this.callReply(PresetStopReplySchema, 'preset-teardown', { presetId }, 10 * 60_000);
+        return result;
+    }
+    /**
+     * Start every declared process and resource, in dependency order. The
+     * daemon reads its own graph; `declared` counts what it found.
+     */
+    async startAll(options) {
+        return this.callReply(StartAllReplySchema, 'start-all', { options }, rpcTimeoutForPreset(options, 30 * 60_000));
+    }
+    /**
+     * Start one declared process or resource by id, with its declared
+     * dependencies and conflicts, resolved by the daemon against its graph.
+     * A target with dependencies runs as a preset, so it gets the preset budget.
+     */
+    async startDeclared(id, options, target = {}) {
+        // `kind: 'process'`: a resource id refuses `pm-target-not-process` before any setup.
+        const params = target.kind ? { id, options, kind: target.kind } : { id, options };
+        const { started } = await this.callReply(StartDeclaredReplySchema, 'start-declared', params, rpcTimeoutForPreset(options, 30 * 60_000));
+        return started;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Worker Runtime Management
+    // ─────────────────────────────────────────────────────────────────────────────
+    async ensureWorkerRuntime(target) {
+        await this.rpc('ensure-worker-runtime', createWorkerRuntimeRequest(target, (await this.workspace()).workspacePath));
+    }
+    /**
+     * Whether the worker runtime answers on its socket. No PM daemon listening
+     * (confirmed absence) is `false`; any other failure propagates typed.
+     */
+    async checkWorkersReady(timeout = 5000, target) {
+        const rpcTimeout = Math.max(1000, timeout + 500);
+        const read = await attempt(async () => this.readReply(WorkersReadyReplySchema, 'check-workers-ready', {
+            ...createWorkerRuntimeRequest(target, (await this.workspace()).workspacePath),
+            timeout
+        }, rpcTimeout));
+        if (read.ok)
+            return read.value.ready ?? false;
+        if (isDaemonUnavailableError(read.failure))
+            return false;
+        return rethrowFailure(read.failure);
+    }
+    async cleanupSocket(processId) {
+        await this.rpc('cleanup-socket', { processId });
+    }
+    async getSocketStatus(processId) {
+        const { status } = await this.readReply(SocketStatusReplySchema, 'socket-status', { processId });
+        return status;
+    }
+    /**
+     * Disconnect from daemon (no-op for HTTP - connections are stateless)
+     */
+    disconnect() {
+        // HTTP connections are stateless - nothing to disconnect
+    }
+}
+//# sourceMappingURL=client.js.map