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

package/dist/managers/preset-executor.js

@@ -0,0 +1,763 @@
+/**
+ * Preset Executor
+ * Orchestrates preset lifecycle with unified process + resource dependency resolution
+ */
+import * as z from 'zod/v4';
+import { CapabilityError, CaughtFailureSchema, getRuntimeHostCommands, getRuntimeStdio, isCapabilityError, requireRuntimeCwd } from '@vibesdotdev/kernel';
+import { isProcessExited } from "../schemas/process.js";
+import { DependencyResolver } from "./dependency-resolver.js";
+import { composeHookEnv } from "../helpers/process-credentials.js";
+import { redactedExcerpt } from '@vibesdotdev/shared/utils';
+import { isWaitTimeout } from "../utils/bounded-wait.js";
+import { attempt, failureText } from "../utils/attempt.js";
+import { waitForProcessState } from "../services/state-wait.js";
+import { readPMBudget } from "../graph.js";
+import { runTimedCapture } from '@vibesdotdev/kernel/execution';
+import { Semaphore } from "../utils/semaphore.js";
+import { resolveHookCommand } from "../services/process-command.js";
+function emptyStartResult() {
+    return { success: true, resourcesSetup: [], processesStarted: [], errors: [] };
+}
+const DEFAULT_PROCESS_START_CONCURRENCY = 4;
+const DEFAULT_LIFECYCLE_HOOK_TIMEOUT_MS = 120_000;
+/** The most of a hook's output a failure message carries. */
+const HOOK_OUTPUT_EXCERPT_CHARS = 4_000;
+/**
+ * How many processes one batch starts at once: the declared budget
+ * (`config.plugins.pm.budget.processStartConcurrency`, H1), else the preset's
+ * `maxProcessConcurrency`, else the default. Declared config, never an env
+ * knob (the `PM_PROCESS_START_CONCURRENCY` read is deleted, pm.md S9).
+ */
+async function resolveProcessStartConcurrency(preset, runtime) {
+    const budget = await readPMBudget(runtime);
+    return budget.processStartConcurrency ?? preset.maxProcessConcurrency ?? DEFAULT_PROCESS_START_CONCURRENCY;
+}
+const PositiveTimeoutSchema = z.number().positive();
+function positiveTimeout(value, fallback) {
+    const parsed = PositiveTimeoutSchema.safeParse(value);
+    return parsed.success ? parsed.data : fallback;
+}
+/**
+ * `work` under a deadline on the runtime lifecycle (RC07). With no deadline it
+ * still ends on the runtime's disposal. On the deadline it rejects `message`.
+ */
+async function withTimeout(runtime, work, timeoutMs, message, reason) {
+    const waited = await attempt(() => runtime.lifecycle.wait(work, { timeoutMs: timeoutMs ?? MAX_UNBOUNDED_WAIT_MS, reason }));
+    if (waited.ok)
+        return waited.value;
+    if (timeoutMs && isWaitTimeout(waited.failure)) {
+        throw new CapabilityError(message, 'TIMEOUT', {
+            reason: `${reason}-timeout`,
+            details: { timeoutMs },
+            cause: waited.failure
+        });
+    }
+    throw waited.failure;
+}
+/** The preset's progress lines: results on stdout, diagnostics on stderr, through the runtime's host text output. */
+async function openPresetOutput(runtime) {
+    const stdio = await getRuntimeStdio(runtime);
+    return {
+        out: (msg) => stdio.write('stdout', `${msg}\n`),
+        err: (msg) => stdio.write('stderr', `${msg}\n`)
+    };
+}
+/** The failure of a node that is already running: success for the batch that wanted it running. */
+function isAlreadyRunning(failure) {
+    return isCapabilityError(failure) && failure.code === 'CONFLICT' && failure.reason === 'process-already-running';
+}
+/** The longest wait the lifecycle admits: "no deadline" still ends on disposal. */
+const MAX_UNBOUNDED_WAIT_MS = 2_147_483_647;
+function emptyStopResult() {
+    return { success: true, processesStopped: [], resourcesTornDown: [], errors: [] };
+}
+/**
+ * Preset Executor
+ * Coordinates resource setup and process startup based on dependencies
+ */
+export class PresetExecutor {
+    processManager;
+    resourceManager;
+    getRuntime;
+    dependencyResolver;
+    constructor(processManager, resourceManager, 
+    /** The daemon's runtime; a getter, so it follows hot-reload generations. */
+    getRuntime) {
+        this.processManager = processManager;
+        this.resourceManager = resourceManager;
+        this.getRuntime = getRuntime;
+        this.dependencyResolver = new DependencyResolver();
+    }
+    /**
+     * Expand a preset's explicitly-listed process/resource ids into the full set
+     * that must be operated on, transitively pulling in every declared dependency.
+     *
+     * A preset only lists the things you care about (e.g. an app process), but
+     * those declare `dependencies` on resources/processes the preset never names
+     * (e.g. a port-forward, a namespace, a TLS secret). Without this expansion the
+     * dependency graph is built from the filtered-down set only, so either
+     * `buildGraph` throws "Dependency not found" or the dependency silently never
+     * starts. Expanding here means a process's dependencies are registered and
+     * started automatically, regardless of whether the preset names them.
+     *
+     * @param presetProcessIds  Process ids the preset explicitly lists
+     * @param presetResourceIds Resource ids the preset explicitly lists
+     * @param allProcesses      Full pool of known process configs
+     * @param allResources      Full pool of known resource configs
+     */
+    expandWithDependencies(presetProcessIds, presetResourceIds, allProcesses, allResources) {
+        const processById = new Map(allProcesses.map((p) => [p.id, p]));
+        const resourceById = new Map(allResources.map((r) => [r.id, r]));
+        const includedProcesses = new Map();
+        const includedResources = new Map();
+        const queue = [];
+        // Seed the queue with whatever the preset explicitly names.
+        for (const id of presetProcessIds) {
+            const config = processById.get(id);
+            if (config && !includedProcesses.has(id)) {
+                includedProcesses.set(id, config);
+                queue.push(id);
+            }
+        }
+        for (const id of presetResourceIds) {
+            const config = resourceById.get(id);
+            if (config && !includedResources.has(id)) {
+                includedResources.set(id, config);
+                queue.push(id);
+            }
+        }
+        // Walk declared dependencies breadth-first, pulling each into the set.
+        // Unknown ids are left out so buildGraph still surfaces a clear
+        // "Dependency not found" error for genuine typos / missing configs.
+        while (queue.length > 0) {
+            const id = queue.shift();
+            const processConfig = includedProcesses.get(id);
+            const config = processConfig ?? includedResources.get(id);
+            // `requiresPass` gates are pulled in alongside `dependencies`: a preset
+            // naming an app must also operate the task that gates it (a migration,
+            // a seed), or the app is scheduled against a gate nothing will satisfy.
+            const deps = [...(config?.dependencies ?? []), ...(processConfig?.requiresPass ?? [])];
+            for (const depId of deps) {
+                if (includedProcesses.has(depId) || includedResources.has(depId))
+                    continue;
+                const depResource = resourceById.get(depId);
+                if (depResource) {
+                    includedResources.set(depId, depResource);
+                    queue.push(depId);
+                    continue;
+                }
+                const depProcess = processById.get(depId);
+                if (depProcess) {
+                    includedProcesses.set(depId, depProcess);
+                    queue.push(depId);
+                }
+            }
+        }
+        return {
+            processes: Array.from(includedProcesses.values()),
+            resources: Array.from(includedResources.values())
+        };
+    }
+    /**
+     * Start a preset - setup resources and start processes
+     */
+    async start(preset, processConfigs, resourceConfigs, options = {}) {
+        const result = emptyStartResult();
+        const presetStartTime = Date.now();
+        const { out } = await openPresetOutput(this.getRuntime());
+        out(`\n🚀 Starting preset '${preset.name || preset.id}'...\n`);
+        try {
+            // 1. Stop mutually exclusive processes before bootstrap/start.
+            await this.stopConflictingProcesses(preset.conflicts ?? []);
+            // 2. Run bootstrap hook if present
+            if (preset.bootstrap) {
+                await this.runHook(preset.bootstrap, 'bootstrap');
+            }
+            // 3. Resolve the preset's processes/resources, transitively pulling in
+            // every declared dependency so they're registered + started automatically
+            // even when the preset itself doesn't name them.
+            const { processes: presetProcesses, resources: presetResources } = this.expandWithDependencies(preset.processes ?? [], preset.resources ?? [], processConfigs, resourceConfigs);
+            // 4. Build dependency graph
+            const graph = this.dependencyResolver.buildGraph(presetProcesses, presetResources);
+            // 5. Detect cycles
+            const cycles = this.dependencyResolver.detectCycles(graph);
+            if (cycles) {
+                throw new CapabilityError(`Dependency cycles detected:\n${cycles.map((c) => c.description).join('\n')}`, 'INVALID_INPUT', { reason: 'pm-dependency-cycle', details: { cycles: cycles.map((c) => c.path) } });
+            }
+            // 6. Get execution order (batches for parallel execution)
+            const batches = this.dependencyResolver.resolveStartupOrder(graph);
+            // Track failed nodes for fail-fast cascading
+            const failedNodes = new Set();
+            // Gate process starts to avoid vite/rolldown thundering-herd CPU thrash.
+            const processSemaphore = new Semaphore(await resolveProcessStartConcurrency(preset, this.getRuntime()));
+            // 7. Execute batches in order, waiting for each batch to be healthy before next
+            // This ensures dependencies are actually ready, not just started
+            for (let i = 0; i < batches.length; i++) {
+                const batch = batches[i];
+                await this.executeBatch(batch, result, failedNodes, graph, processSemaphore);
+                // Wait for this batch's processes to become healthy before starting next batch
+                // This is critical for dependency ordering (e.g., port-forwards must be healthy before apps start)
+                const batchProcesses = batch.flatMap((n) => (n.type === 'process' ? [n.config] : []));
+                const batchResources = batch.flatMap((n) => (n.type === 'resource' ? [n.config] : []));
+                // Only wait if there's a next batch that might depend on this one
+                if (i < batches.length - 1 && (batchProcesses.length > 0 || batchResources.length > 0)) {
+                    await this.waitForBatchReady(batchResources, batchProcesses, result, failedNodes, options);
+                }
+            }
+            // 8. Final health check for last batch (only for items that succeeded)
+            const succeededResources = presetResources.filter((r) => result.resourcesSetup.includes(r.id));
+            const succeededProcesses = presetProcesses.filter((p) => result.processesStarted.includes(p.id));
+            await this.waitForAllReady(succeededResources, succeededProcesses, result, options);
+            // Final summary with total time
+            const totalElapsed = ((Date.now() - presetStartTime) / 1000).toFixed(1);
+            const successCount = result.resourcesSetup.length + result.processesStarted.length;
+            const errorCount = result.errors.length;
+            const totalItems = successCount + errorCount;
+            if (errorCount === 0) {
+                out(`\n✅ Preset '${preset.id}' ready: ${totalItems} item(s) in ${totalElapsed}s\n`);
+            }
+            else if (successCount === 0) {
+                // Complete failure - nothing could be started
+                result.success = false;
+                out(`\n❌ Preset '${preset.id}' failed: all ${errorCount} item(s) failed in ${totalElapsed}s\n`);
+            }
+            else {
+                // Partial success - some items started, others failed
+                out(`\n⚠️  Preset '${preset.id}': ${successCount}/${totalItems} ready, ${errorCount} error(s) in ${totalElapsed}s\n`);
+            }
+            return result;
+        }
+        catch (error) {
+            const totalElapsed = ((Date.now() - presetStartTime) / 1000).toFixed(1);
+            out(`\n❌ Preset '${preset.id}' failed after ${totalElapsed}s\n`);
+            result.success = false;
+            result.errors.push({
+                id: preset.id,
+                error: failureText(CaughtFailureSchema.parse(error))
+            });
+            throw error;
+        }
+    }
+    /**
+     * Stop a preset - stop processes and teardown resources
+     */
+    async stop(preset, processConfigs, resourceConfigs) {
+        const result = emptyStopResult();
+        try {
+            // 1. Resolve the preset's processes + their transitive dependencies, so
+            // dependency processes stop too and the graph includes the resources they
+            // reference (needed so buildGraph doesn't throw on a process→resource dep).
+            const { processes: presetProcesses, resources: presetResources } = this.expandWithDependencies(preset.processes ?? [], preset.resources ?? [], processConfigs, resourceConfigs);
+            // 2. Build dependency graph. Resources are included only to satisfy
+            // process dependency edges; the stop below is non-destructive (process
+            // stop only) so resources are never torn down here.
+            const graph = this.dependencyResolver.buildGraph(presetProcesses, presetResources);
+            // 3. Get teardown order (reverse of startup) for processes only
+            const batches = this.dependencyResolver.resolveTeardownOrder(graph);
+            // 4. Execute teardown batches (process stop only)
+            for (const batch of batches) {
+                const processOnly = batch.filter((node) => node.type === 'process');
+                await this.teardownProcessBatch(processOnly, result);
+            }
+            return result;
+        }
+        catch (error) {
+            result.success = false;
+            result.errors.push({
+                id: preset.id,
+                error: failureText(CaughtFailureSchema.parse(error))
+            });
+            throw error;
+        }
+    }
+    /**
+     * Restart a preset
+     */
+    async restart(preset, processConfigs, resourceConfigs, options = {}) {
+        // Stop first (non-destructive)
+        await this.stop(preset, processConfigs, resourceConfigs);
+        // No settle sleep: stop() returns once each process's exit is proven.
+        // Start again
+        return this.start(preset, processConfigs, resourceConfigs, options);
+    }
+    /**
+     * Teardown a preset - stop processes and teardown resources (destructive)
+     */
+    async teardown(preset, processConfigs, resourceConfigs) {
+        const result = emptyStopResult();
+        try {
+            const { processes: presetProcesses, resources: presetResources } = this.expandWithDependencies(preset.processes ?? [], preset.resources ?? [], processConfigs, resourceConfigs);
+            const graph = this.dependencyResolver.buildGraph(presetProcesses, presetResources);
+            const batches = this.dependencyResolver.resolveTeardownOrder(graph);
+            for (const batch of batches) {
+                await this.teardownBatch(batch, result);
+            }
+            if (preset.teardown) {
+                await this.runHook(preset.teardown, 'teardown');
+            }
+            return result;
+        }
+        catch (error) {
+            result.success = false;
+            result.errors.push({
+                id: preset.id,
+                error: failureText(CaughtFailureSchema.parse(error))
+            });
+            throw error;
+        }
+    }
+    /**
+     * Execute a batch of nodes in parallel
+     * Tracks failed nodes to enable fail-fast for dependent nodes
+     */
+    /**
+     * True when a node is a finite `runOnce` task that has already passed, so a
+     * plan that merely depends on its outcome should not run it again.
+     */
+    async isSatisfiedRunOnceTask(config) {
+        if (!config.task || !config.runOnce)
+            return false;
+        // A store read failure propagates: an unreadable outcome never reads as "not passed" (a rerun).
+        const status = await this.processManager.getStatus(config.id);
+        return status?.status === 'pass';
+    }
+    async executeBatch(batch, result, failedNodes, graph, processSemaphore) {
+        const { out, err } = await openPresetOutput(this.getRuntime());
+        // Log what we're starting in this batch
+        const resources = batch.filter((n) => n.type === 'resource').map((n) => n.id);
+        const processes = batch.filter((n) => n.type === 'process').map((n) => n.id);
+        if (resources.length > 0) {
+            out(`🔧 Setting up resource(s): ${resources.join(', ')}`);
+        }
+        if (processes.length > 0) {
+            const gate = processSemaphore ? ` (max ${processSemaphore.limit} concurrent)` : '';
+            out(`🚀 Starting process(es): ${processes.join(', ')}${gate}`);
+        }
+        const runNode = async (node) => {
+            // Check if any dependency has failed - if so, skip this node (fail-fast)
+            const deps = this.dependencyResolver.getDependencies(node.id, graph);
+            const failedDeps = deps.filter((depId) => failedNodes.has(depId));
+            if (failedDeps.length > 0) {
+                const errorMessage = `Skipped: dependency failed (${failedDeps.join(', ')})`;
+                err(`  ⏭️  Skipping ${node.id}: ${errorMessage}`);
+                result.errors.push({
+                    id: node.id,
+                    error: errorMessage
+                });
+                failedNodes.add(node.id);
+                return;
+            }
+            // A resource already sitting in 'error' from a prior attempt is not
+            // re-attempted here: `resourceManager.setup()` can legitimately run
+            // for minutes (onCreate hook + waitForReady) before it gives up, and
+            // every `pm start <dependent>` re-running that same slow failure is
+            // exactly the "blocked 30 minutes on a known-broken dependency"
+            // incident this guard exists for (2026-09-02: `ai-router` waited the
+            // full 30min preset-start RPC timeout behind a failing
+            // `lmstudio-router-models` hook). The cached error is reported
+            // immediately instead, within this reconcile tick. `vibes pm start
+            // <resourceId>` bypasses the executor entirely (see
+            // pm.start.impl.ts's bare-resource branch) and is the explicit,
+            // unthrottled way to force a fresh attempt.
+            if (node.type === 'resource') {
+                const priorState = await this.resourceManager.getState(node.id);
+                if (priorState?.status === 'error') {
+                    const lastErrorLine = (priorState.lastError ?? priorState.error ?? 'unknown error')
+                        .split('\n')[0];
+                    const errorMessage = `Resource ${node.id} already failed: ${lastErrorLine} (not retried automatically — run \`vibes pm start ${node.id}\` to force)`;
+                    err(`  ❌ ${node.id}: ${errorMessage}`);
+                    result.errors.push({
+                        id: node.id,
+                        error: errorMessage
+                    });
+                    failedNodes.add(node.id);
+                    return;
+                }
+            }
+            const ran = await attempt(async () => {
+                if (node.type === 'resource') {
+                    await this.resourceManager.setup(node.config);
+                    out(`  ✅ Resource setup complete: ${node.id}`);
+                    result.resourcesSetup.push(node.id);
+                }
+                else if (await this.isSatisfiedRunOnceTask(node.config)) {
+                    // `runOnce` means once. The gate it opens is already open, so the
+                    // plan is satisfied without re-running it — a migration or seed
+                    // pulled in as a `requiresPass` dependency must not re-execute on
+                    // every app start. `pm start <task>` / `pm restart <task>` remain
+                    // the explicit ways to run it again.
+                    out(`  ℹ️  Already passed: ${node.id}`);
+                    result.processesStarted.push(node.id);
+                }
+                else {
+                    await this.processManager.start(node.config);
+                    out(`  ✅ Process started: ${node.id}`);
+                    result.processesStarted.push(node.id);
+                }
+            });
+            if (ran.ok)
+                return;
+            // If process is already running, treat as success (it's running!)
+            if (isAlreadyRunning(ran.failure)) {
+                out(`  ℹ️  Already running: ${node.id}`);
+                if (node.type === 'process') {
+                    result.processesStarted.push(node.id);
+                }
+                else {
+                    result.resourcesSetup.push(node.id);
+                }
+                return;
+            }
+            // Real error - add to errors list and track as failed
+            const errorMessage = failureText(ran.failure);
+            err(`  ❌ Error with ${node.id}: ${errorMessage}`);
+            result.errors.push({
+                id: node.id,
+                error: errorMessage
+            });
+            failedNodes.add(node.id);
+        };
+        // Resources can go fully parallel — cheap setup. Processes gate through the
+        // shared semaphore so vite/rolldown cold starts don't thrash the machine.
+        // Critically, the semaphore holds until the process is *healthy*, not just
+        // spawned. processManager.start() returns immediately after spawn; vite's
+        // pre-bundle scan then transiently opens thousands of package.json fds for
+        // the next few minutes. Releasing the slot on spawn means every process
+        // ends up warming up concurrently and the system runs out of file handles
+        // (ENFILE) regardless of maxProcessConcurrency. Waiting for healthy
+        // serializes the warmup phase so only `limit` processes are FD-hot at once.
+        const promises = batch.map(async (node) => {
+            if (node.type !== 'process' || !processSemaphore) {
+                return runNode(node);
+            }
+            await processSemaphore.acquire();
+            try {
+                await runNode(node);
+                if (result.processesStarted.includes(node.id)) {
+                    await this.waitForProcessWarmup(node.config);
+                }
+            }
+            finally {
+                processSemaphore.release();
+            }
+        });
+        await Promise.all(promises);
+    }
+    /**
+     * Stop every running process in `processIds`. Used internally as step 1 of
+     * `start()` for a preset's own `preset.conflicts`, and reused (not
+     * duplicated) by the daemon's `start` command handler so a direct `pm
+     * start <id>` honors `conflicts` declared on presets that list the
+     * process, not only `pm preset start` — see command-handler.ts.
+     */
+    async stopConflictingProcesses(processIds) {
+        if (processIds.length === 0)
+            return;
+        const { out, err } = await openPresetOutput(this.getRuntime());
+        out(`🧹 Stopping conflicting process(es): ${processIds.join(', ')}`);
+        await Promise.all(processIds.map(async (processId) => {
+            const stopped = await attempt(async () => {
+                const status = await this.processManager.getStatus(processId);
+                if (status?.status !== 'running')
+                    return false;
+                await this.processManager.stop(processId);
+                return true;
+            });
+            if (!stopped.ok) {
+                err(`  ⚠️  Could not stop conflict ${processId}: ${failureText(stopped.failure)}`);
+            }
+            else if (stopped.value) {
+                out(`  ✅ Stopped conflict: ${processId}`);
+            }
+        }));
+    }
+    /**
+     * Wait for a process to finish its warmup phase so the start-semaphore can
+     * release its slot. Returns when the process is healthy, crashed, stopped,
+     * or its warmupMs budget has elapsed — whichever comes first. Processes
+     * without a healthCheck are treated as "instantly warm" (no wait).
+     */
+    async waitForProcessWarmup(config) {
+        if (!config.healthCheck)
+            return;
+        // The owner's event: this process's next state write (healthy, crashed
+        // or stopped), bounded by its warmup budget. The deadline is not a failure.
+        await waitForProcessState(this.getRuntime(), this.processManager, config.id, (state) => state.status === 'crashed' ||
+            state.status === 'stopped' ||
+            (state.status === 'running' && state.healthStatus === 'healthy'), { timeoutMs: config.healthCheck.warmupMs || 30000, reason: 'pm-process-warmup' });
+    }
+    /**
+     * Teardown a batch of nodes in parallel
+     */
+    async teardownBatch(batch, result) {
+        const promises = batch.map(async (node) => {
+            const torn = await attempt(async () => {
+                if (node.type === 'process') {
+                    await this.processManager.stop(node.id);
+                    result.processesStopped.push(node.id);
+                }
+                else {
+                    await this.resourceManager.teardown(node.id);
+                    result.resourcesTornDown.push(node.id);
+                }
+            });
+            // Don't rethrow - continue with other nodes
+            if (!torn.ok)
+                result.errors.push({ id: node.id, error: failureText(torn.failure) });
+        });
+        await Promise.all(promises);
+    }
+    /**
+     * Teardown batch for processes only (non-destructive stop)
+     */
+    async teardownProcessBatch(batch, result) {
+        const promises = batch.map(async (node) => {
+            if (node.type !== 'process')
+                return;
+            const stopped = await attempt(async () => {
+                // A finished task has nothing to stop, and its `pass`/`fail` record
+                // is the very thing `requiresPass` reads. Stopping it would overwrite
+                // that outcome with a liveness status and re-close the gate.
+                // A read failure lands in this node's error below, not in a blind stop.
+                const status = await this.processManager.getStatus(node.id);
+                if (status?.status === 'pass' || status?.status === 'fail')
+                    return;
+                await this.processManager.stop(node.id);
+                result.processesStopped.push(node.id);
+            });
+            if (!stopped.ok)
+                result.errors.push({ id: node.id, error: failureText(stopped.failure) });
+        });
+        await Promise.all(promises);
+    }
+    /**
+     * Wait for all resources and processes to be ready
+     */
+    async waitForAllReady(resources, processes, result, options = {}) {
+        const { out } = await openPresetOutput(this.getRuntime());
+        // Wait for resources with waitForReady=true
+        const resourcesToWait = resources.filter((r) => r.waitForReady);
+        if (resourcesToWait.length > 0) {
+            out(`⏳ Waiting for ${resourcesToWait.length} resource(s) to be ready: ${resourcesToWait.map((r) => r.id).join(', ')}`);
+        }
+        const resourceWaits = resourcesToWait.map(async (r) => {
+            const state = await this.resourceManager.getState(r.id);
+            if (state && state.status !== 'ready') {
+                out(`  ⌛ Waiting for resource: ${r.id} (current status: ${state.status})`);
+                await withTimeout(this.getRuntime(), (signal) => this.resourceManager.waitForReady(r, state, { signal }), options.wait ? options.timeout : undefined, `Resource ${r.id} did not become ready within ${options.timeout}ms`, 'pm-resource-ready');
+                out(`  ✅ Resource ready: ${r.id}`);
+            }
+            else if (state && state.status === 'ready') {
+                out(`  ✅ Resource already ready: ${r.id}`);
+            }
+        });
+        // Wait for processes with health checks to become healthy
+        // This ensures processes are actually serving before we report success
+        // Only wait for processes that have health checks AND were successfully started
+        const startedProcessIds = new Set(result.processesStarted);
+        const processesWithHealthChecks = processes.filter((p) => p.healthCheck && startedProcessIds.has(p.id));
+        if (processesWithHealthChecks.length > 0) {
+            out(`⏳ Waiting for ${processesWithHealthChecks.length} process(es) to become healthy: ${processesWithHealthChecks.map((p) => p.id).join(', ')}`);
+        }
+        const processWaits = processesWithHealthChecks.map(async (p) => {
+            const timeout = options.wait
+                ? positiveTimeout(options.timeout, p.healthCheck?.warmupMs || 30000)
+                : p.healthCheck?.warmupMs || 30000; // Use warmup as initial timeout
+            const startTime = performance.now();
+            const elapsedSec = () => ((performance.now() - startTime) / 1000).toFixed(1);
+            let lastLoggedStatus = '';
+            // Each committed state write of this process is the event (RC07).
+            const settled = await waitForProcessState(this.getRuntime(), this.processManager, p.id, (status) => {
+                if (status.status === 'crashed' || status.status === 'stopped') {
+                    out(`  ⚠️  Process ${p.id} is ${status.status} after ${elapsedSec()}s, skipping health wait`);
+                    return true;
+                }
+                if (status.status === 'running' && status.healthStatus === 'healthy') {
+                    out(`  ✅ Process healthy: ${p.id} (${elapsedSec()}s)`);
+                    return true;
+                }
+                const currentStatus = `${status.status}:${status.healthStatus || 'unknown'}`;
+                if (currentStatus !== lastLoggedStatus) {
+                    out(`  ⌛ Waiting for ${p.id}: ${status.status}, health=${status.healthStatus || 'unknown'} (${elapsedSec()}s/${(timeout / 1000).toFixed(0)}s)`);
+                    lastLoggedStatus = currentStatus;
+                }
+                return false;
+            }, { timeoutMs: timeout, reason: 'pm-process-healthy' });
+            if (settled)
+                return;
+            // Timeout reached - check final status
+            const finalStatus = await this.processManager.getStatus(p.id);
+            if (finalStatus?.status === 'running') {
+                // Process is running, even if health is unknown - that's acceptable
+                out(`  ℹ️  Process ${p.id} running (health: ${finalStatus.healthStatus || 'unknown'}, ${elapsedSec()}s)`);
+            }
+            else {
+                out(`  ⚠️  Process ${p.id} did not become healthy within ${timeout}ms`);
+            }
+        });
+        await Promise.all([...resourceWaits, ...processWaits]);
+        if (resourcesToWait.length > 0) {
+            out(`✅ All resources are ready`);
+        }
+        if (processesWithHealthChecks.length > 0) {
+            out(`✅ All processes checked`);
+        }
+    }
+    /**
+     * Wait for a batch of resources and processes to be ready
+     * Shorter timeout than waitForAllReady - just enough for dependencies
+     * Marks resources/processes as failed if they don't become ready (for fail-fast cascading)
+     */
+    async waitForBatchReady(resources, processes, result, failedNodes, options = {}) {
+        const { out, err } = await openPresetOutput(this.getRuntime());
+        // Wait for resources with waitForReady=true that were successfully set up
+        const setupResourceIds = new Set(result.resourcesSetup);
+        const resourcesToWait = resources.filter((r) => r.waitForReady && setupResourceIds.has(r.id));
+        const resourceWaits = resourcesToWait.map(async (r) => {
+            const ready = await attempt(async () => {
+                const state = await this.resourceManager.getState(r.id);
+                if (state && state.status !== 'ready') {
+                    await withTimeout(this.getRuntime(), (signal) => this.resourceManager.waitForReady(r, state, { signal }), options.wait ? options.timeout : undefined, `Resource ${r.id} did not become ready within ${options.timeout}ms`, 'pm-resource-ready');
+                }
+            });
+            if (ready.ok)
+                return;
+            // Resource failed to become ready - mark as failed for cascading
+            const errorMessage = failureText(ready.failure);
+            err(`  ❌ Resource ${r.id} failed to become ready: ${errorMessage}`);
+            result.errors.push({ id: r.id, error: errorMessage });
+            // Remove from resourcesSetup since it's not actually ready
+            const idx = result.resourcesSetup.indexOf(r.id);
+            if (idx !== -1)
+                result.resourcesSetup.splice(idx, 1);
+            failedNodes.add(r.id);
+        });
+        // Wait for processes with health checks to become healthy
+        const startedProcessIds = new Set(result.processesStarted);
+        const processesWithHealthChecks = processes.filter((p) => p.healthCheck && startedProcessIds.has(p.id));
+        const processWaits = processesWithHealthChecks.map(async (p) => {
+            const timeout = options.wait
+                ? positiveTimeout(options.timeout, p.healthCheck?.warmupMs || 30000)
+                : p.healthCheck?.warmupMs || 30000;
+            const startTime = performance.now();
+            // Each committed state write of this process is the event (RC07).
+            const settled = await waitForProcessState(this.getRuntime(), this.processManager, p.id, (status) => status.status === 'crashed' ||
+                status.status === 'stopped' ||
+                (status.status === 'running' && status.healthStatus === 'healthy'), { timeoutMs: timeout, reason: 'pm-process-healthy' });
+            if (settled?.status === 'crashed' || settled?.status === 'stopped') {
+                // Crashed or stopped: mark as failed for cascading.
+                const errorMessage = `Process ${settled.status}`;
+                err(`  ❌ ${p.id}: ${errorMessage}`);
+                result.errors.push({ id: p.id, error: errorMessage });
+                const idx = result.processesStarted.indexOf(p.id);
+                if (idx !== -1)
+                    result.processesStarted.splice(idx, 1);
+                failedNodes.add(p.id);
+                return;
+            }
+            if (settled) {
+                out(`  ✅ ${p.id} ready (${((performance.now() - startTime) / 1000).toFixed(1)}s)`);
+                return;
+            }
+            // Timeout - log warning but continue (dependent processes will fail if truly broken)
+            out(`  ⚠️  ${p.id} not healthy within ${(timeout / 1000).toFixed(0)}s, continuing...`);
+        });
+        await Promise.all([
+            ...resourceWaits,
+            ...processWaits,
+            ...this.waitForTasks(processes, result, failedNodes, options)
+        ]);
+    }
+    /**
+     * Wait for finite tasks in a batch to reach their terminal outcome.
+     *
+     * A task has no health check — it runs and exits — so the health-check wait
+     * above skips it entirely and the next batch starts while the task is still
+     * running. Anything gated on it by `requiresPass` then fails on a gate that
+     * was moments from opening. Batch readiness for a task means `pass`.
+     */
+    waitForTasks(processes, result, failedNodes, options = {}) {
+        const startedProcessIds = new Set(result.processesStarted);
+        return processes
+            .filter((p) => p.task && startedProcessIds.has(p.id))
+            .map(async (p) => {
+            const { out, err } = await openPresetOutput(this.getRuntime());
+            const timeout = positiveTimeout(options.wait ? options.timeout : undefined, 300_000);
+            const startTime = performance.now();
+            const fail = (message) => {
+                err(`  ❌ ${p.id}: ${message}`);
+                result.errors.push({ id: p.id, error: message });
+                const idx = result.processesStarted.indexOf(p.id);
+                if (idx !== -1)
+                    result.processesStarted.splice(idx, 1);
+                failedNodes.add(p.id);
+            };
+            // Each committed state write of this task is the event (RC07).
+            const outcome = await waitForProcessState(this.getRuntime(), this.processManager, p.id, isProcessExited, { timeoutMs: timeout, reason: 'pm-task-outcome' });
+            if (!outcome) {
+                fail(`Task did not finish within ${(timeout / 1000).toFixed(0)}s`);
+            }
+            else if (outcome.status === 'pass') {
+                out(`  ✅ ${p.id} passed (${((performance.now() - startTime) / 1000).toFixed(1)}s)`);
+            }
+            else {
+                fail(outcome.lastError ?? `Task ${outcome.status}`);
+            }
+        });
+    }
+    /**
+     * Run a lifecycle hook
+     */
+    async runHook(hook, hookType) {
+        // A preset hook is a PM child (C15): the base set, the host's re-entry
+        // facts and roots, the names it inherits, its cwd's `.env`, its env, and
+        // its declared credentials resolved at spawn (D-RC05), never argv.
+        const runtime = this.getRuntime();
+        const cwd = hook.cwd ?? requireRuntimeCwd(runtime);
+        const hookEnv = await composeHookEnv(runtime, hook, cwd, `preset:${hookType}`);
+        const hostCommands = hook.selfSpawn ? await getRuntimeHostCommands(runtime) : undefined;
+        const resolved = resolveHookCommand(hook, hostCommands, `PM preset ${hookType} hook`);
+        const timeoutMs = positiveTimeout(hook.timeout, DEFAULT_LIFECYCLE_HOOK_TIMEOUT_MS);
+        // The hook's whole environment is the one composed above.
+        const ran = await attempt(() => runTimedCapture(runtime, resolved.command, resolved.args, {
+            env: hookEnv.env,
+            envMode: 'replace',
+            cwd,
+            timeoutMs
+        }));
+        if (!ran.ok) {
+            hookEnv.audit('failure');
+            throw ran.failure;
+        }
+        const { exitCode, timedOut } = ran.value;
+        hookEnv.audit(exitCode === 0 && !timedOut ? 'success' : 'failure');
+        // A credential the hook printed never reaches the failure message: its
+        // output is a bounded, credential-free excerpt.
+        const excerpt = (text) => redactedExcerpt(text, { secrets: hookEnv.redact, maxChars: HOOK_OUTPUT_EXCERPT_CHARS });
+        const stdout = excerpt(ran.value.stdout);
+        const stderr = excerpt(ran.value.stderr);
+        if (timedOut) {
+            const detail = (stderr || stdout).trim();
+            const message = `${hookType} hook timed out after ${timeoutMs}ms${detail ? `: ${detail}` : ''}`;
+            if (!hook.ignoreFailure) {
+                throw new CapabilityError(message, 'TIMEOUT', {
+                    reason: 'pm-hook-timeout',
+                    details: { hookType, timeoutMs }
+                });
+            }
+            (await openPresetOutput(runtime)).err(message);
+            return;
+        }
+        if (exitCode !== 0) {
+            const message = `${hookType} hook failed: ${stderr || stdout}`;
+            if (!hook.ignoreFailure) {
+                throw new CapabilityError(message, 'UNAVAILABLE', {
+                    reason: 'pm-hook-failed',
+                    details: { hookType, exitCode }
+                });
+            }
+            (await openPresetOutput(runtime)).err(message);
+        }
+    }
+}
+//# sourceMappingURL=preset-executor.js.map