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

package/dist/manager.js

@@ -0,0 +1,682 @@
+/**
+ * Process Manager
+ * Thin orchestrator composing lifecycle, health, cleanup, and workers services
+ */
+import { AWAIT_EXIT_MAX_MS, AwaitExitOptionsSchema, isLaterRun, isProcessExited, isSameRun, processExitOf } from "./schemas/process.js";
+import { waitForProcessState } from "./services/state-wait.js";
+import { TaskSupervision } from "./services/task-supervision.js";
+import { ProcessStore } from "./store.impl.consumer.js";
+import { getWorkspaceProcessLogDir } from "./utils/vibes-home.js";
+import { getLogger } from '@vibesdotdev/logging';
+import { checkProcessLiveness, isProcessAlive, ownsLivePid } from "./utils/liveness.js";
+// isProcessRunning imported in liveness.ts
+import { resolveWorkerSocketPath } from "./utils/socket-paths.js";
+import { getSocketInfo, removeSocket, testSocketConnectivity } from "./utils/socket.js";
+import { LifecycleService } from "./services/lifecycle.js";
+import { HealthMonitor } from "./services/health.js";
+import { CleanupService } from "./services/cleanup.js";
+import { bindWorkerRuntimeProcessConfig, ensureWorkerRuntime } from "./services/workers.js";
+import { bindProcessLaunchCustody } from "./helpers/launch-custody.js";
+import { processLaunchIdentity } from "./helpers/launch-identity.js";
+import { CapabilityError, getRuntimeHostIdentity } from '@vibesdotdev/kernel';
+import { attempt, failureLabel } from "./utils/attempt.js";
+import { hasErrno, rethrowFailure } from "./helpers/failure.js";
+import { pmFileSystem, readByteRange, readBytesFile, statSizeIfPresent } from "./helpers/runtime-files.js";
+import { getPathRoots, getRuntimePath } from '@vibesdotdev/paths';
+import { resolveBoundWorkerWorkspaceRoot } from "./helpers/worker-routing.js";
+import { admittedWorkspaceIdentity } from "./admission.js";
+import { isWaitTimeout } from "./utils/bounded-wait.js";
+import { readPMBudget } from "./graph.js";
+import { redactCredentials } from '@vibesdotdev/shared/utils';
+/**
+ * The complete lines `path` gained since `offset` and the offset after them.
+ * A log not written yet (`ENOENT`) has gained nothing; a log that shrank is
+ * read again from 0. Any other failure propagates.
+ */
+export async function readCompleteLinesSince(files, path, offset) {
+    const size = await statSizeIfPresent(files, path);
+    if (size === undefined)
+        return { text: '', next: 0 };
+    const from = size < offset ? 0 : offset;
+    if (size === from)
+        return { text: '', next: from };
+    // Only the bytes gained are read, through the ranged read.
+    const gained = await readByteRange(files, path, from, size);
+    const end = gained.lastIndexOf(0x0a);
+    if (end < 0)
+        return { text: '', next: from };
+    return { text: new TextDecoder().decode(gained.subarray(0, end + 1)), next: from + end + 1 };
+}
+export async function readProcessLogFile(files, path, lines) {
+    if (!lines) {
+        return new TextDecoder().decode(await readBytesFile(files, path));
+    }
+    return readProcessLogTail(files, path, lines);
+}
+/** How far back one step of the tail read goes. */
+const TAIL_READ_STEP_BYTES = 64 * 1024;
+/** The run `state` names, when it has started one. */
+function runOf(state) {
+    return state.startedAt ? { startedAt: state.startedAt } : undefined;
+}
+export async function readProcessLogTail(files, path, lines) {
+    const size = await statSizeIfPresent(files, path);
+    // A log that is not there is a failed read, as it was when the whole file was read.
+    if (size === undefined)
+        return new TextDecoder().decode(await readBytesFile(files, path));
+    if (size === 0)
+        return '';
+    // Walk back from the end in steps until `lines` + 1 newlines have been seen: everything after
+    // the last of them is the `lines` complete lines (and the trailing partial one). Only the
+    // steps walked are read, through the ranged read.
+    let from = size;
+    let newlineCount = 0;
+    let tail = new Uint8Array(0);
+    let start = 0;
+    while (from > 0) {
+        const stepFrom = Math.max(0, from - TAIL_READ_STEP_BYTES);
+        const step = await readByteRange(files, path, stepFrom, from);
+        const joined = new Uint8Array(step.length + tail.length);
+        joined.set(step);
+        joined.set(tail, step.length);
+        tail = joined;
+        from = stepFrom;
+        let found = false;
+        for (let index = step.length - 1; index >= 0; index--) {
+            if (step[index] !== 10)
+                continue;
+            newlineCount++;
+            if (newlineCount > lines) {
+                start = index + 1;
+                found = true;
+                break;
+            }
+        }
+        if (found)
+            break;
+    }
+    const content = new TextDecoder().decode(tail.subarray(start));
+    const normalized = content.endsWith('\n') ? content.slice(0, -1) : content;
+    return normalized.split('\n').slice(-lines).join('\n');
+}
+/** The deadline of one serialized start or restart before it refuses `pm-start-restart-timeout`. */
+export const START_OR_RESTART_TIMEOUT_MS = 120_000;
+export class ProcessManager {
+    store;
+    lifecycle;
+    healthMonitor;
+    taskSupervision;
+    cleanup;
+    logDir;
+    startOrRestartTimeoutMs;
+    scope;
+    workspaceIdentity;
+    inFlightStartOrRestart = new Map();
+    /** Operator-initiated ends in flight, so the run-end archive can name them. */
+    pendingRunEndInitiators = new Map();
+    /** Path mechanics from the constructing caller's runtime (required for 'global'). */
+    runtimePath;
+    /** The runtime the constructing caller was handed (a getter; see ProcessManagerOptions). */
+    getRuntime;
+    /** `getPathRoots(runtime)`, captured at construction. */
+    roots;
+    /** The handed runtime's Logging, read per entry so it follows hot-reload generations (C083a). */
+    get logger() {
+        return getLogger('pm:manager', this.getRuntime());
+    }
+    constructor(scope, resourceManager, options) {
+        this.scope = scope;
+        this.startOrRestartTimeoutMs = options.startOrRestartTimeoutMs ?? START_OR_RESTART_TIMEOUT_MS;
+        this.getRuntime = options.getRuntime;
+        this.roots = getPathRoots(options.getRuntime());
+        this.runtimePath = options.runtimePath;
+        this.workspaceIdentity = admittedWorkspaceIdentity(options.workspaceRoot);
+        // Thread the admitted identity through explicitly: without it both stores
+        // re-derive workspace identity ambiently (cwd/env at first access), which
+        // can disagree with this manager's admitted workspaceRoot and make two
+        // managers for two different workspaces collide on one 'global'-scope
+        // partition — clobbering each other's process config/state, including a
+        // worker's persisted socketPath that a health probe reads back verbatim.
+        this.store =
+            options.store ??
+                new ProcessStore(scope === 'global'
+                    ? { scope, roots: this.roots, workspaceToolingId: this.workspaceIdentity.toolingId }
+                    : { scope, workspaceRoot: this.workspaceIdentity.workspacePath }, options.getRuntime());
+        this.taskSupervision = new TaskSupervision(this.store, {
+            workspacePath: this.workspaceIdentity.workspacePath, toolingId: this.workspaceIdentity.toolingId
+        });
+        this.logDir = this.getLogDir(scope);
+        const lifecycleConfig = {
+            logDir: this.logDir,
+            resourceManager,
+            // An environment without the capability has no graph identity (null);
+            // one that has it and fails propagates.
+            graphIdentity: (root) => options.getRuntime().localEnvironment.graphIdentity?.(root) ?? null,
+            getRuntime: options.getRuntime
+        };
+        if (options.daemonScope)
+            lifecycleConfig.daemonScope = options.daemonScope;
+        if (options.livenessProfile)
+            lifecycleConfig.livenessProfile = options.livenessProfile;
+        this.lifecycle = new LifecycleService(this.store, lifecycleConfig);
+        this.healthMonitor = new HealthMonitor(this.store, options.getRuntime);
+        this.cleanup = new CleanupService(this.store, this.logDir, options.getRuntime, {
+            ephemeralTimeoutMs: options?.ephemeralCleanupTimeoutMs
+        }, this.store);
+    }
+    getLogDir(scope) {
+        switch (scope) {
+            case 'global':
+                if (!this.runtimePath) {
+                    throw new CapabilityError("ProcessManager 'global' scope requires options.runtimePath (resolve it with getRuntimePath(runtime)).", 'INVALID_INPUT', { reason: 'pm-manager-runtime-path-required', details: { scope } });
+                }
+                return getWorkspaceProcessLogDir(this.workspaceIdentity.toolingId, {
+                    roots: this.roots,
+                    runtimePath: this.runtimePath
+                });
+            case 'project':
+            case 'local':
+                // `workspacePath` is absolute, and every host accepts `/` between path segments.
+                return this.runtimePath
+                    ? this.runtimePath.join(this.workspaceIdentity.workspacePath, '.vibes', 'logs')
+                    : `${this.workspaceIdentity.workspacePath}/.vibes/logs`;
+        }
+    }
+    /** Directory holding this manager's `<id>.stdout` / `<id>.stderr`. */
+    get processLogDir() {
+        return this.logDir;
+    }
+    async getLogPaths(processId) {
+        const path = await this.pathService();
+        return {
+            stdout: path.join(this.logDir, `${processId}.stdout`),
+            stderr: path.join(this.logDir, `${processId}.stderr`)
+        };
+    }
+    async runStartOrRestartLocked(processId, config, operation, deduplicate = true) {
+        // A supervised daemon command already owns this process admission. Waiting
+        // on a separate launch caller queued behind it would deadlock the owner.
+        if (await this.store.currentTaskAdmission(processId))
+            return operation();
+        // A concurrent request shares the in-flight result only when it would
+        // launch the same process (its full launch identity, env included);
+        // any other request runs next with its own config.
+        const launchIdentity = processLaunchIdentity(config);
+        const existing = this.inFlightStartOrRestart.get(processId);
+        if (existing) {
+            if (!deduplicate) {
+                await existing.promise;
+                return this.runStartOrRestartLocked(processId, config, operation, false);
+            }
+            if (existing.launchIdentity !== launchIdentity) {
+                // The identity carries env values: log the process id only (RC05).
+                this.logger.warn('Concurrent start with a different launch identity, serializing', { processId });
+                // The earlier request's own caller receives its failure; this request runs next regardless.
+                const earlier = await attempt(() => existing.promise);
+                if (!earlier.ok) {
+                    this.logger.debug('existing promise rejected during restart serialization', { failure: failureLabel(earlier.failure) });
+                }
+                return this.runStartOrRestartLocked(processId, config, operation);
+            }
+            return existing.promise;
+        }
+        // The serialized operation is bounded by the runtime lifecycle (RC07).
+        const promise = (async () => {
+            const waited = await attempt(() => this.getRuntime().lifecycle.wait(() => operation(), { timeoutMs: this.startOrRestartTimeoutMs, reason: 'pm-start-or-restart' }));
+            if (waited.ok)
+                return waited.value;
+            if (isWaitTimeout(waited.failure)) {
+                throw new CapabilityError(`Process ${processId} start/restart timed out after ${this.startOrRestartTimeoutMs}ms`, 'TIMEOUT', {
+                    reason: 'pm-start-restart-timeout',
+                    details: { processId, timeoutMs: this.startOrRestartTimeoutMs },
+                    cause: waited.failure
+                });
+            }
+            return rethrowFailure(waited.failure);
+        })();
+        this.inFlightStartOrRestart.set(processId, { promise, launchIdentity });
+        try {
+            return await promise;
+        }
+        finally {
+            const current = this.inFlightStartOrRestart.get(processId);
+            if (current?.promise === promise) {
+                this.inFlightStartOrRestart.delete(processId);
+            }
+        }
+    }
+    // Process Lifecycle (delegated to LifecycleService)
+    /** The injected path service, or the one the handed runtime registers. Never cached here. */
+    async pathService() {
+        return this.runtimePath ?? (await getRuntimePath(this.getRuntime()));
+    }
+    bindAdmittedProcessConfig(config, runtimePath) {
+        return bindProcessLaunchCustody(bindWorkerRuntimeProcessConfig(config, this.workspaceIdentity.workspacePath, {
+            roots: this.roots,
+            runtimePath
+        }), this.workspaceIdentity.workspacePath);
+    }
+    /**
+     * Enforce the declared budget (H1) on a NEW start: with
+     * `maxManagedProcesses` managed processes already running or starting, a
+     * start of another is refused `RATE_LIMITED` `pm-budget-max-processes`.
+     * (Re)starting a process already counted adds nothing; nothing running is
+     * ever stopped to honour a tightened budget.
+     */
+    async admitWithinBudget(processId) {
+        const { maxManagedProcesses } = await readPMBudget(this.getRuntime());
+        if (maxManagedProcesses === undefined)
+            return;
+        const live = (await this.getAllStatus()).filter((state) => (state.status === 'running' || state.status === 'starting') && state.id !== processId);
+        if (live.length < maxManagedProcesses)
+            return;
+        throw new CapabilityError(`Starting '${processId}' would exceed the declared budget of ${maxManagedProcesses} managed processes.`, 'RATE_LIMITED', {
+            reason: 'pm-budget-max-processes',
+            retryable: true,
+            recoveryHint: "Stop a process, or raise config.plugins.pm.budget.maxManagedProcesses.",
+            details: { processId, maxManagedProcesses, live: live.length }
+        });
+    }
+    async start(input, options) {
+        await this.admitWithinBudget(input.id);
+        const config = this.bindAdmittedProcessConfig(input, await this.pathService());
+        if (!(await this.store.currentTaskAdmission(input.id)))
+            await this.cleanup.cleanupStale();
+        return this.runStartOrRestartLocked(config.id, config, async () => {
+            const state = await this.lifecycle.start(config, options);
+            if (config.healthCheck) {
+                this.healthMonitor.start(config.id, config);
+                if (options?.wait) {
+                    await this.healthMonitor.waitForHealthy(config.id, config, options.timeout ?? 30_000, runOf(state));
+                    return (await this.store.get(config.id)) ?? state;
+                }
+            }
+            return state;
+        });
+    }
+    /**
+     * The operator command currently ending `processId`'s run, if any. The
+     * daemon's previous-run log archive (services/process-log-archive.ts) names
+     * the exit banner's initiator from it.
+     */
+    pendingRunEndInitiator(processId) {
+        return this.pendingRunEndInitiators.get(processId);
+    }
+    async stop(processId, options) {
+        if (options?.run) {
+            const state = await this.store.get(processId);
+            if (!state || !isSameRun(state, options.run))
+                throw new CapabilityError('The requested process run was superseded.', 'CONFLICT', {
+                    reason: 'pm-stop-run-superseded', details: { processId }
+                });
+        }
+        this.healthMonitor.stop(processId);
+        this.pendingRunEndInitiators.set(processId, 'stop-rpc');
+        try {
+            await this.lifecycle.stop(processId, options);
+        }
+        finally {
+            this.pendingRunEndInitiators.delete(processId);
+        }
+    }
+    restart(processId, options, guard) {
+        // Fetch config first for the lock signature check
+        return this.store.getConfig(processId).then((config) => {
+            if (!config) {
+                throw new CapabilityError(`Process config not found: ${processId}`, 'NOT_FOUND', {
+                    reason: 'pm-process-config-not-found',
+                    details: { processId }
+                });
+            }
+            return this.runStartOrRestartLocked(processId, config, () => this.store.withProcessAdmission(processId, async () => {
+                await this.store.assertTaskReleaseAvailable(processId);
+                if (guard?.expectedPid !== undefined) {
+                    const tracked = await this.store.get(processId);
+                    if (tracked?.pid !== guard.expectedPid) {
+                        throw new CapabilityError(`restart refused: '${processId}' is tracked as pid ${tracked?.pid ?? 'none'}; the requester expected pid ${guard.expectedPid}`, 'CONFLICT', {
+                            reason: 'pm-restart-pid-mismatch',
+                            details: { processId, expectedPid: guard.expectedPid, trackedPid: tracked?.pid }
+                        });
+                    }
+                }
+                this.healthMonitor.stop(processId);
+                this.pendingRunEndInitiators.set(processId, 'restart-rpc');
+                let state;
+                try {
+                    state = await this.lifecycle.restart(processId, options);
+                }
+                finally {
+                    this.pendingRunEndInitiators.delete(processId);
+                }
+                if (config?.healthCheck) {
+                    this.healthMonitor.start(processId, config);
+                    if (options?.wait) {
+                        await this.healthMonitor.waitForHealthy(processId, config, options.timeout ?? 30_000, runOf(state));
+                        return (await this.store.get(processId)) ?? state;
+                    }
+                }
+                return state;
+            }), guard?.expectedPid === undefined);
+        });
+    }
+    // Status and Queries
+    async getStatus(processId) {
+        await this.cleanup.cleanupStale();
+        let state = await this.store.get(processId);
+        if (!state)
+            return undefined;
+        if (state.status === 'running') {
+            const observed = state;
+            const livenessResult = await checkProcessLiveness(this.getRuntime(), state);
+            const unresponsive = livenessResult.details.socketExists === false || livenessResult.details.socketConnectable === false;
+            if (!livenessResult.alive &&
+                unresponsive &&
+                (await ownsLivePid(this.getRuntime(), state, await this.store.getConfig(processId)))) {
+                // Its socket is not answering yet, but the process is alive and ours:
+                // still booting or busy. It stays `running`; the liveness checker
+                // owns escalation for one that never answers.
+                return state;
+            }
+            if (!livenessResult.alive) {
+                const updates = livenessResult.details.socketExists && !livenessResult.details.socketConnectable
+                    ? {
+                        status: 'crashed',
+                        stoppedAt: new Date(),
+                        staleSocket: true,
+                        lastError: `Crashed: ${livenessResult.details.reason}`
+                    }
+                    : {
+                        status: 'stopped',
+                        stoppedAt: new Date(),
+                        lastError: livenessResult.details.reason
+                    };
+                // Liveness describes the row read before its awaits, never a terminal
+                // record or replacement generation committed while the probe ran.
+                const changed = await this.store.updateWhen(processId, updates, current => current.status === 'running' && current.pid === observed.pid &&
+                    current.startedAt?.getTime() === observed.startedAt?.getTime());
+                if (changed)
+                    this.logger.warn(`Process ${processId} not alive: ${livenessResult.details.reason}`);
+                state = await this.store.get(processId);
+            }
+        }
+        return state;
+    }
+    async getAllStatus() {
+        await this.cleanup.cleanupStale();
+        return this.store.getAll();
+    }
+    /**
+     * Whether `processId` is running. A live child of ours whose socket does not
+     * answer yet is booting or busy: running, and its record stays as it is
+     * (getStatus already left it `running`). Only a dead or foreign pid is
+     * recorded stopped. Recording a booting child `stopped` with its pid kept
+     * made the next start kill it as an orphan (2026-10-11 workers loop).
+     */
+    async isRunning(processId) {
+        const state = await this.getStatus(processId);
+        if (state?.status !== 'running')
+            return false;
+        if (await isProcessAlive(this.getRuntime(), state))
+            return true;
+        if (await ownsLivePid(this.getRuntime(), state, await this.store.getConfig(processId)))
+            return true;
+        const changed = await this.store.updateWhen(processId, { status: 'stopped', stoppedAt: new Date(), pid: undefined }, current => current.status === 'running' && current.pid === state.pid &&
+            current.startedAt?.getTime() === state.startedAt?.getTime());
+        if (!changed)
+            return (await this.store.get(processId))?.status === 'running';
+        this.lifecycle.removeProcess(processId);
+        return false;
+    }
+    async health() {
+        const pid = (await getRuntimeHostIdentity(this.getRuntime())).currentPid();
+        if (!Number.isSafeInteger(pid) || pid <= 0) {
+            throw new CapabilityError('The selected host supplied an invalid process identity.', 'INVALID_INPUT', {
+                reason: 'pm-host-pid-invalid', retryable: false
+            });
+        }
+        const states = await this.getAllStatus();
+        const running = states.filter((s) => s.status === 'running');
+        return {
+            healthy: true,
+            uptime: 0,
+            version: '1.0.0',
+            processCount: states.length,
+            runningCount: running.length,
+            timestamp: new Date(),
+            pid
+        };
+    }
+    // Activity Tracking
+    async touch(processId, timestamp) {
+        const state = await this.store.get(processId);
+        if (!state)
+            return;
+        const time = timestamp instanceof Date ? timestamp : new Date(timestamp ?? Date.now());
+        await this.store.update(processId, { lastActivity: time });
+    }
+    // Cleanup (delegated to CleanupService)
+    async cleanupIdleProcesses(_now = Date.now()) {
+        const result = await this.cleanup.cleanupIdle((id) => this.stop(id));
+        return result.cleaned;
+    }
+    async cleanupEphemeralProcesses(_now = Date.now()) {
+        const result = await this.cleanup.cleanupEphemeral();
+        return result.cleaned;
+    }
+    /** Remove the process logs older than `maxAgeMs` (see `CleanupService.cleanupExpiredLogs`). */
+    cleanupExpiredLogs(maxAgeMs) {
+        return this.cleanup.cleanupExpiredLogs(maxAgeMs);
+    }
+    getEphemeralCleanupTimeoutMs() {
+        return this.cleanup.getEphemeralTimeout();
+    }
+    setEphemeralCleanupTimeoutMs(timeoutMs) {
+        this.cleanup.setEphemeralTimeout(timeoutMs);
+    }
+    // Logs
+    async getLogs(processId, options = {}) {
+        const logPaths = await this.getLogPaths(processId);
+        const files = await pmFileSystem(this.getRuntime());
+        const streams = [];
+        const streamOption = options.stream ?? 'both';
+        if (streamOption === 'stdout' || streamOption === 'both')
+            streams.push('stdout');
+        if (streamOption === 'stderr' || streamOption === 'both')
+            streams.push('stderr');
+        const logs = [];
+        for (const stream of streams) {
+            const path = stream === 'stdout' ? logPaths.stdout : logPaths.stderr;
+            const read = await attempt(() => readProcessLogFile(files, path, options.lines));
+            if (read.ok) {
+                logs.push(`=== ${stream.toUpperCase()} ===\n${read.value}`);
+            }
+            else if (!hasErrno(read.failure, 'ENOENT')) {
+                return rethrowFailure(read.failure);
+            }
+        }
+        if (logs.length === 0)
+            return '';
+        // RC05: a credential the process printed never reaches a read surface.
+        return redactCredentials(logs.join('\n\n'), await this.lifecycle.logRedactions(processId));
+    }
+    /**
+     * What each stream gained since `offsets`, redacted (RC05), for `pm logs
+     * --follow`. Only complete lines are returned, so a value never straddles
+     * two reads unredacted; the partial tail waits for its newline. A stream
+     * that shrank was rotated or truncated and is read again from 0.
+     */
+    async readLogsSince(processId, offsets) {
+        const paths = await this.getLogPaths(processId);
+        const files = await pmFileSystem(this.getRuntime());
+        const redactions = await this.lifecycle.logRedactions(processId);
+        const stdout = await readCompleteLinesSince(files, paths.stdout, offsets.stdout);
+        const stderr = await readCompleteLinesSince(files, paths.stderr, offsets.stderr);
+        return {
+            stdout: redactCredentials(stdout.text, redactions),
+            stderr: redactCredentials(stderr.text, redactions),
+            offsets: { stdout: stdout.next, stderr: stderr.next }
+        };
+    }
+    // Health Checking (delegated to HealthMonitor)
+    async waitForHealthy(processId, timeout = 30000) {
+        const config = await this.store.getConfig(processId);
+        if (!config?.healthCheck)
+            return;
+        await this.healthMonitor.waitForHealthy(processId, config, timeout);
+    }
+    // Config records (pm-state.db `process_configs`; pm.md K8)
+    async register(config) {
+        await this.cleanup.cleanupStale();
+        await this.store.setConfig(this.bindAdmittedProcessConfig(config, await this.pathService()));
+    }
+    async registerMany(configs) {
+        await this.cleanup.cleanupStale();
+        const runtimePath = await this.pathService();
+        await this.store.setConfigs(configs.map((config) => this.bindAdmittedProcessConfig(config, runtimePath)));
+    }
+    async unregister(processId) {
+        if (await this.isRunning(processId)) {
+            throw new CapabilityError(`Cannot unregister ${processId}: process is running`, 'CONFLICT', {
+                reason: 'pm-process-running',
+                details: { processId }
+            });
+        }
+        return this.removeCompletely(processId);
+    }
+    admitSupervisedTask(identity, config, release, launch, signal) {
+        return this.taskSupervision.admit(identity, config, release, launch, signal);
+    }
+    supervisedAdmission(identity) {
+        return this.taskSupervision.lookup(identity);
+    }
+    acknowledgeSupervised(receipt) {
+        return this.taskSupervision.acknowledge(receipt, () => this.removeCompletely(receipt.processId));
+    }
+    /**
+     * Remove a process through cleanup's one removal path (state, stored
+     * config, socket and logs). Returns whether a stored config existed.
+     */
+    async removeCompletely(processId) {
+        const state = await this.store.get(processId);
+        const unregistered = await this.cleanup.removeProcess(processId, state?.socketPath);
+        this.lifecycle.removeProcess(processId);
+        return unregistered;
+    }
+    /** Observe this manager's committed process state writes (see ProcessStore.onStateChange). */
+    onStateChange(listener) {
+        return this.store.onStateChange(listener);
+    }
+    /**
+     * How `processId`'s run exits: its committed terminal record, awaited on
+     * the store's state writes (RC07; nothing polls). `run` names the run to
+     * await (absent: the run current now); a stale terminal record of an
+     * earlier run never answers it, and a later run refuses `CONFLICT`
+     * `pm-await-exit-run-superseded`. The deadline refuses `TIMEOUT`
+     * `pm-await-exit-timeout`; the caller's signal and the runtime's disposal
+     * end it with the lifecycle's `CANCELLED` `wait-aborted`. Refusals carry
+     * the process id only.
+     */
+    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 current = await this.store.get(processId);
+        if (!current) {
+            throw new CapabilityError(`Process '${processId}' has no state to await.`, 'NOT_FOUND', {
+                reason: 'pm-process-state-not-found',
+                details: { processId }
+            });
+        }
+        const timeoutMs = parsed.data.timeoutMs ?? AWAIT_EXIT_MAX_MS;
+        const run = parsed.data.run ?? (current.startedAt ? { startedAt: current.startedAt } : undefined);
+        const settled = await waitForProcessState(this.getRuntime(), this, processId, (state) => (isProcessExited(state) && (!run || isSameRun(state, run))) || (run !== undefined && isLaterRun(state, run)), { timeoutMs, reason: 'pm-await-exit', signal: options.signal });
+        if (!settled) {
+            throw new CapabilityError(`Process '${processId}' did not exit within ${timeoutMs}ms.`, 'TIMEOUT', {
+                reason: 'pm-await-exit-timeout',
+                retryable: true,
+                details: { processId, timeoutMs }
+            });
+        }
+        const exit = run && isLaterRun(settled, run) ? undefined : processExitOf(settled);
+        if (!exit) {
+            throw new CapabilityError(`Process '${processId}' started a later run before the awaited one exited.`, 'CONFLICT', {
+                reason: 'pm-await-exit-run-superseded',
+                details: { processId }
+            });
+        }
+        return exit;
+    }
+    getConfig(processId) {
+        return this.store.getConfig(processId);
+    }
+    getAllConfigs() {
+        return this.store.getAllConfigs();
+    }
+    isRegistered(processId) {
+        return this.store.hasConfig(processId);
+    }
+    async upsert(config) {
+        await this.store.setConfig(this.bindAdmittedProcessConfig(config, await this.pathService()));
+    }
+    async remove(processId, options = {}) {
+        if (await this.isRunning(processId)) {
+            await this.stop(processId, options);
+        }
+        await this.removeCompletely(processId);
+    }
+    // Config Cache
+    async isConfiguredProcess(processId) {
+        const configured = await this.lifecycle.loadConfiguredProcessIds();
+        return configured.has(processId);
+    }
+    invalidateConfigCache() {
+        this.lifecycle.invalidateConfigCache();
+    }
+    // Socket Status
+    async getSocketStatus(processId) {
+        const state = await this.store.get(processId);
+        if (!state?.socketPath) {
+            return { exists: false, connectable: false };
+        }
+        const info = await getSocketInfo(this.getRuntime(), state.socketPath);
+        return {
+            exists: info.exists,
+            connectable: info.connectable,
+            path: state.socketPath
+        };
+    }
+    async cleanupSocket(processId) {
+        const state = await this.store.get(processId);
+        if (state?.socketPath) {
+            await removeSocket(this.getRuntime(), state.socketPath);
+        }
+    }
+    // Workers API — enqueue / streaming / status moved to @vibesdotdev/workers
+    // `WorkersClient`. Only the low-level lifecycle helpers used by the
+    // IPC adapter's `LocalWorkerManager` remain on the manager.
+    resolveWorkerWorkspaceRoot(context) {
+        return resolveBoundWorkerWorkspaceRoot(this.workspaceIdentity.workspacePath, context);
+    }
+    async ensureWorkerRuntime(target, context) {
+        await ensureWorkerRuntime(this, target, this.resolveWorkerWorkspaceRoot(context), this.getRuntime());
+    }
+    async checkWorkersReady(timeout = 5000, target, context) {
+        const runtime = this.getRuntime();
+        const resolvedTarget = target ?? (runtime.scope.hardware === 'cloud' ? 'cloud' : 'consumer');
+        const workspaceRoot = this.resolveWorkerWorkspaceRoot(context);
+        const socketPath = await resolveWorkerSocketPath(undefined, {
+            runtime,
+            ensure: false,
+            hardware: resolvedTarget,
+            workspace: workspaceRoot
+        });
+        // The socket owner answers reachability (absent or refused is `false`);
+        // anything it throws is a real failure and propagates typed.
+        return testSocketConnectivity(runtime, socketPath, timeout);
+    }
+}
+//# sourceMappingURL=manager.js.map