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

package/dist/schemas/executable-freshness.d.ts

@@ -0,0 +1,88 @@
+import type { RuntimeHostIdentity, RuntimeRef, VibesRuntime } from '@vibesdotdev/kernel';
+import type { RuntimeLogger } from '@vibesdotdev/logging';
+import type { ProcessConfig, ProcessState } from './process.ts';
+export interface ReconcilerProcessManager {
+    getAllStatus(): Promise<ProcessState[]>;
+    getConfig(processId: string): Promise<ProcessConfig | undefined>;
+    restart(processId: string): Promise<ProcessState | void>;
+}
+export type ReconcilerLogger = Pick<RuntimeLogger, 'info' | 'warn' | 'error'>;
+/**
+ * The runtime the daemon was handed: its host command identity names the
+ * handoff, its execution provider runs it, its snapshot and roots are the
+ * handoff's whole environment, and its environment declares this daemon's R.
+ */
+export type ReconcilerRuntime = RuntimeRef & Pick<VibesRuntime, 'localEnvironment'>;
+export interface ExecutableFreshnessReconcilerDeps {
+    /**
+     * The daemon's runtime (see {@link ReconcilerRuntime}), as a getter so the
+     * handoff runs on the current hot-reload generation. Required: nothing is
+     * read ambiently.
+     */
+    getRuntime: () => ReconcilerRuntime;
+    pm: ReconcilerProcessManager;
+    /** When this daemon started (ms). */
+    selfStartedAtMs: number;
+    /** This daemon's executable (default: the host identity's captured executable). */
+    selfExecutablePath?: string;
+    /** Default: the runtime's `VIBES_PM_EXECUTABLE_FRESHNESS` is not '0' (an env knob; RC04 moves it). */
+    enabled?: boolean;
+    /** The new file must be unchanged this long before anything execs it (default 30s). */
+    settleMs?: number;
+    /** Minimum spacing between rolls of the same process id (default 5 min). */
+    cooldownMs?: number;
+    /**
+     * Circuit breaker: after this many rolls of one child without its recorded
+     * graph digest changing, stop rolling it (default 3). A roll that leaves the
+     * child exactly as stale as before is not repairing anything.
+     */
+    maxIdenticalRolls?: number;
+    now?: () => number;
+    /** Test seam: OS start time of a pid. */
+    readProcessStart?: (pid: number) => number | null;
+    /** Test seam: OS executable path of a pid (PM may store a bare `vibes`). */
+    readProcessExecutable?: (pid: number) => string | null;
+    /** Test seam: the graph nerve. */
+    graphReplaced?: RuntimeHostIdentity['graphReplacedSince'];
+    /** Test seam: the executable nerve. */
+    executableReplaced?: RuntimeHostIdentity['executableReplacedSince'];
+    /** This daemon's own resolution root (default: the one its runtime's environment declares). */
+    selfHostRoot?: string | null;
+    /** The lock digest this daemon loaded (default: read at construction). */
+    selfGraphDigest?: string | null;
+    /** Test seam: how the daemon hands off to a fresh one. */
+    handoff?: () => Promise<void>;
+    logger?: ReconcilerLogger;
+}
+export interface ReconcileReport {
+    enabled: boolean;
+    /** true = this daemon runs a replaced binary. */
+    selfReplaced: boolean | null;
+    /** true = the module graph under this daemon's own root moved after it booted. */
+    selfGraphReplaced: boolean | null;
+    handoffRequested: boolean;
+    /** Children found stale by EITHER nerve this tick. */
+    stale: string[];
+    /** Why each stale child is stale: `executable` | `graph` | `executable+graph`. */
+    staleReasons: Record<string, string>;
+    /**
+     * Children neither nerve could judge and neither found stale — typically a
+     * child PM spawned without persisting its graph stamp. Counted here, NEVER
+     * in `stale`; never rolled; never block the handoff.
+     */
+    unknown: string[];
+    unknownReasons: Record<string, string>;
+    /**
+     * Stale children whose circuit breaker is open: rolled `maxIdenticalRolls`
+     * times without their recorded digest changing. Still listed in `stale`
+     * (they ARE stale) but not rolled again and not blocking the handoff.
+     */
+    tripped: string[];
+    /** The child rolled this tick (at most one). */
+    rolled: string | null;
+    deferred: Array<{
+        id: string;
+        reason: string;
+    }>;
+}
+//# sourceMappingURL=executable-freshness.d.ts.map

package/dist/schemas/executable-freshness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executable-freshness.d.ts","sourceRoot":"","sources":["../../src/schemas/executable-freshness.ts"],"names":[],"mappings":"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"}

package/dist/schemas/executable-freshness.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=executable-freshness.js.map

package/dist/schemas/executable-freshness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executable-freshness.js","sourceRoot":"","sources":["../../src/schemas/executable-freshness.ts"],"names":[],"mappings":""}

package/dist/schemas/forward-config.d.ts

@@ -0,0 +1,11 @@
+import * as z from 'zod/v4';
+export declare const PortForwardConfigSchema: z.ZodObject<{
+    namespace: z.ZodOptional<z.ZodString>;
+    service: z.ZodString;
+    localPort: z.ZodNumber;
+    remotePort: z.ZodNumber;
+    context: z.ZodOptional<z.ZodString>;
+    additionalFlags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    labelSelector: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//# sourceMappingURL=forward-config.d.ts.map

package/dist/schemas/forward-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forward-config.d.ts","sourceRoot":"","sources":["../../src/schemas/forward-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAM5B,eAAO,MAAM,uBAAuB;;;;;;;;iBAQlC,CAAC"}

package/dist/schemas/forward-config.js

@@ -0,0 +1,15 @@
+import * as z from 'zod/v4';
+// Compatibility input for the public synchronous builders; provider configuration is open.
+const DnsLabelSchema = z.string().min(1).max(63).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/);
+const PortSchema = z.number().int().positive().max(65535);
+const OptionTextSchema = z.string().min(1).regex(/^[^\p{Cc}]+$/u);
+export const PortForwardConfigSchema = z.object({
+    namespace: DnsLabelSchema.optional(),
+    service: DnsLabelSchema,
+    localPort: PortSchema,
+    remotePort: PortSchema,
+    context: OptionTextSchema.optional(),
+    additionalFlags: z.array(z.string()).optional(),
+    labelSelector: OptionTextSchema.optional()
+});
+//# sourceMappingURL=forward-config.js.map

package/dist/schemas/forward-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forward-config.js","sourceRoot":"","sources":["../../src/schemas/forward-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,2FAA2F;AAC3F,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,iCAAiC,CAAC,CAAC;AAC1F,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AAC1D,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;AAClE,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,SAAS,EAAE,cAAc,CAAC,QAAQ,EAAE;IACpC,OAAO,EAAE,cAAc;IACvB,SAAS,EAAE,UAAU;IACrB,UAAU,EAAE,UAAU;IACtB,OAAO,EAAE,gBAAgB,CAAC,QAAQ,EAAE;IACpC,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IAC/C,aAAa,EAAE,gBAAgB,CAAC,QAAQ,EAAE;CAC1C,CAAC,CAAC"}

package/dist/schemas/graph.d.ts

@@ -0,0 +1,444 @@
+/** PM's graph contracts: the declared plugin config with its budget and supervision policies, the graph PM reads and the sources it could not read. */
+import * as z from 'zod/v4';
+import { type ProcessConfig, type ProcessPreset } from './process.ts';
+import type { ResourceConfig } from './resource.ts';
+/**
+ * PM's declared resource budget (map Unit H1): enforced, never advisory.
+ * - `maxManagedProcesses`: the most managed processes running or starting at
+ *   once in this admitted workspace. A NEW start past it is refused
+ *   `RATE_LIMITED` `pm-budget-max-processes`; running processes are never
+ *   stopped to honour a tightened budget.
+ * - `processStartConcurrency`: how many processes one preset batch starts at
+ *   once. It outranks a preset's own `maxProcessConcurrency` (it replaces the
+ *   old `PM_PROCESS_START_CONCURRENCY` env knob, pm.md S9).
+ */
+export declare const PMBudgetSchema: z.ZodObject<{
+    maxManagedProcesses: z.ZodOptional<z.ZodNumber>;
+    processStartConcurrency: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type PMBudget = z.infer<typeof PMBudgetSchema>;
+/**
+ * One supervised restart policy: attempt `n` waits `baseDelayMs * factor^(n-1)`,
+ * capped at `maxDelayMs`; after `maxConsecutive` consecutive failures the
+ * supervisor stops (absent: it keeps restarting).
+ */
+export declare const PMRestartPolicySchema: z.ZodObject<{
+    baseDelayMs: z.ZodOptional<z.ZodNumber>;
+    factor: z.ZodOptional<z.ZodNumber>;
+    maxDelayMs: z.ZodOptional<z.ZodNumber>;
+    maxConsecutive: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type PMRestartPolicy = z.infer<typeof PMRestartPolicySchema>;
+/**
+ * PM's supervision policy (`config.plugins.pm.supervision`): how the daemon
+ * restarts what it owns. `process` and `portForward` restart crashed managed
+ * children (a process's own `restartDelay`/`maxRestarts` are its declared
+ * base and budget); `daemonModule` restarts the daemon's degraded required
+ * modules; `maxSpawnsPerMinute` is the runaway guard.
+ */
+export declare const PMSupervisionSchema: z.ZodObject<{
+    process: z.ZodOptional<z.ZodObject<{
+        baseDelayMs: z.ZodOptional<z.ZodNumber>;
+        factor: z.ZodOptional<z.ZodNumber>;
+        maxDelayMs: z.ZodOptional<z.ZodNumber>;
+        maxConsecutive: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    portForward: z.ZodOptional<z.ZodObject<{
+        baseDelayMs: z.ZodOptional<z.ZodNumber>;
+        factor: z.ZodOptional<z.ZodNumber>;
+        maxDelayMs: z.ZodOptional<z.ZodNumber>;
+        maxConsecutive: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    daemonModule: z.ZodOptional<z.ZodObject<{
+        baseDelayMs: z.ZodOptional<z.ZodNumber>;
+        factor: z.ZodOptional<z.ZodNumber>;
+        maxDelayMs: z.ZodOptional<z.ZodNumber>;
+        maxConsecutive: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    maxSpawnsPerMinute: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type PMSupervision = z.infer<typeof PMSupervisionSchema>;
+/**
+ * `config.plugins.pm`: an inline manifest (processes, resources, presets,
+ * `defaultPreset`) plus the declared `budget` and `supervision`. Strict, so a key PM no longer
+ * reads (the retired `discoveryRoots`, moved to `package.json#workspaces`) is
+ * refused `plugin-config-invalid` naming it instead of being dropped.
+ */
+export declare const PMPluginConfigSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodString>;
+    defaultPreset: z.ZodOptional<z.ZodString>;
+    processes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        selfSpawn: z.ZodOptional<z.ZodBoolean>;
+        portForward: z.ZodOptional<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            service: z.ZodString;
+            localPort: z.ZodNumber;
+            remotePort: z.ZodNumber;
+            context: z.ZodOptional<z.ZodString>;
+            additionalFlags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            labelSelector: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        launchPreparation: z.ZodOptional<z.ZodObject<{
+            adapter: z.ZodString;
+            config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>>;
+        workerRuntimeTarget: z.ZodOptional<z.ZodEnum<{
+            consumer: "consumer";
+            cloud: "cloud";
+        }>>;
+        cwd: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        inheritEnv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"secret">;
+            key: z.ZodString;
+            store: z.ZodOptional<z.ZodString>;
+            operation: z.ZodOptional<z.ZodCustom<object, object>>;
+        }, z.core.$strict>], "source">>>;
+        ipc: z.ZodDefault<z.ZodBoolean>;
+        socket: z.ZodOptional<z.ZodString>;
+        preBuild: z.ZodOptional<z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            cwd: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            inheritEnv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            ignoreFailure: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        build: z.ZodOptional<z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            cwd: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            inheritEnv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            ignoreFailure: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        watch: z.ZodOptional<z.ZodObject<{
+            patterns: z.ZodArray<z.ZodString>;
+            debounceMs: z.ZodDefault<z.ZodNumber>;
+            minIntervalMs: z.ZodDefault<z.ZodNumber>;
+            quietPeriodMs: z.ZodDefault<z.ZodNumber>;
+            ignore: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        autoRestart: z.ZodDefault<z.ZodBoolean>;
+        codeUpdatePolicy: z.ZodOptional<z.ZodEnum<{
+            runtime: "runtime";
+            restart: "restart";
+        }>>;
+        restartDelay: z.ZodDefault<z.ZodNumber>;
+        maxRestarts: z.ZodDefault<z.ZodNumber>;
+        restartSettleMs: z.ZodDefault<z.ZodNumber>;
+        idleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        task: z.ZodDefault<z.ZodBoolean>;
+        dangerouslyDisableRunawayChecks: z.ZodDefault<z.ZodBoolean>;
+        runOnce: z.ZodDefault<z.ZodBoolean>;
+        retryOnFailure: z.ZodDefault<z.ZodBoolean>;
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        healthCheck: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                custom: "custom";
+                tcp: "tcp";
+                http: "http";
+                socket: "socket";
+            }>;
+            failureAction: z.ZodOptional<z.ZodEnum<{
+                report: "report";
+                restart: "restart";
+            }>>;
+            endpoint: z.ZodOptional<z.ZodString>;
+            portOwnership: z.ZodOptional<z.ZodEnum<{
+                external: "external";
+                managed: "managed";
+            }>>;
+            warmupEndpoints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            port: z.ZodOptional<z.ZodNumber>;
+            host: z.ZodOptional<z.ZodString>;
+            interval: z.ZodDefault<z.ZodNumber>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            retries: z.ZodDefault<z.ZodNumber>;
+            warmupMs: z.ZodDefault<z.ZodNumber>;
+            gracePeriodMultiplier: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        orphanPorts: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        requiresPass: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        scope: z.ZodDefault<z.ZodEnum<{
+            local: "local";
+            global: "global";
+            project: "project";
+        }>>;
+        presets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        livenessProfiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        livenessConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        launchProvenance: z.ZodOptional<z.ZodObject<{
+            declaration: z.ZodObject<{
+                cwd: z.ZodOptional<z.ZodString>;
+                command: z.ZodString;
+                args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                inheritEnv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                socket: z.ZodOptional<z.ZodString>;
+                credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    source: z.ZodLiteral<"secret">;
+                    key: z.ZodString;
+                    store: z.ZodOptional<z.ZodString>;
+                    operation: z.ZodOptional<z.ZodCustom<object, object>>;
+                }, z.core.$strict>], "source">>>;
+                portForward: z.ZodOptional<z.ZodObject<{
+                    namespace: z.ZodOptional<z.ZodString>;
+                    service: z.ZodString;
+                    localPort: z.ZodNumber;
+                    remotePort: z.ZodNumber;
+                    context: z.ZodOptional<z.ZodString>;
+                    additionalFlags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    labelSelector: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                launchPreparation: z.ZodOptional<z.ZodObject<{
+                    adapter: z.ZodString;
+                    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$loose>>;
+                selfSpawn: z.ZodOptional<z.ZodBoolean>;
+                preBuild: z.ZodOptional<z.ZodObject<{
+                    command: z.ZodString;
+                    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    cwd: z.ZodOptional<z.ZodString>;
+                    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    inheritEnv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    ignoreFailure: z.ZodDefault<z.ZodBoolean>;
+                    timeout: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+                build: z.ZodOptional<z.ZodObject<{
+                    command: z.ZodString;
+                    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    cwd: z.ZodOptional<z.ZodString>;
+                    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    inheritEnv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    ignoreFailure: z.ZodDefault<z.ZodBoolean>;
+                    timeout: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            prepared: z.ZodObject<{
+                cwd: z.ZodOptional<z.ZodString>;
+                command: z.ZodString;
+                args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                inheritEnv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                socket: z.ZodOptional<z.ZodString>;
+                credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    source: z.ZodLiteral<"secret">;
+                    key: z.ZodString;
+                    store: z.ZodOptional<z.ZodString>;
+                    operation: z.ZodOptional<z.ZodCustom<object, object>>;
+                }, z.core.$strict>], "source">>>;
+                portForward: z.ZodOptional<z.ZodObject<{
+                    namespace: z.ZodOptional<z.ZodString>;
+                    service: z.ZodString;
+                    localPort: z.ZodNumber;
+                    remotePort: z.ZodNumber;
+                    context: z.ZodOptional<z.ZodString>;
+                    additionalFlags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    labelSelector: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                launchPreparation: z.ZodOptional<z.ZodObject<{
+                    adapter: z.ZodString;
+                    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$loose>>;
+                selfSpawn: z.ZodOptional<z.ZodBoolean>;
+                preBuild: z.ZodOptional<z.ZodObject<{
+                    command: z.ZodString;
+                    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    cwd: z.ZodOptional<z.ZodString>;
+                    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    inheritEnv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    ignoreFailure: z.ZodDefault<z.ZodBoolean>;
+                    timeout: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+                build: z.ZodOptional<z.ZodObject<{
+                    command: z.ZodString;
+                    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    cwd: z.ZodOptional<z.ZodString>;
+                    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    inheritEnv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    ignoreFailure: z.ZodDefault<z.ZodBoolean>;
+                    timeout: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    resources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodString;
+        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        onCreate: z.ZodOptional<z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            cwd: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            inheritEnv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"secret">;
+                key: z.ZodString;
+                store: z.ZodOptional<z.ZodString>;
+                operation: z.ZodOptional<z.ZodCustom<object, object>>;
+            }, z.core.$strict>], "source">>>;
+            selfSpawn: z.ZodOptional<z.ZodBoolean>;
+            ignoreFailure: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        onUpdate: z.ZodOptional<z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            cwd: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            inheritEnv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"secret">;
+                key: z.ZodString;
+                store: z.ZodOptional<z.ZodString>;
+                operation: z.ZodOptional<z.ZodCustom<object, object>>;
+            }, z.core.$strict>], "source">>>;
+            selfSpawn: z.ZodOptional<z.ZodBoolean>;
+            ignoreFailure: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        onDelete: z.ZodOptional<z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            cwd: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            inheritEnv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"secret">;
+                key: z.ZodString;
+                store: z.ZodOptional<z.ZodString>;
+                operation: z.ZodOptional<z.ZodCustom<object, object>>;
+            }, z.core.$strict>], "source">>>;
+            selfSpawn: z.ZodOptional<z.ZodBoolean>;
+            ignoreFailure: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        waitForReady: z.ZodDefault<z.ZodBoolean>;
+        readyTimeout: z.ZodDefault<z.ZodNumber>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        presets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    presets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        processes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        resources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        extends: z.ZodOptional<z.ZodString>;
+        autoStart: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodBoolean>;
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        conflicts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        maxProcessConcurrency: z.ZodOptional<z.ZodNumber>;
+        bootstrap: z.ZodOptional<z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            cwd: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            inheritEnv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"secret">;
+                key: z.ZodString;
+                store: z.ZodOptional<z.ZodString>;
+                operation: z.ZodOptional<z.ZodCustom<object, object>>;
+            }, z.core.$strict>], "source">>>;
+            selfSpawn: z.ZodOptional<z.ZodBoolean>;
+            ignoreFailure: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        teardown: z.ZodOptional<z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            cwd: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            inheritEnv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"secret">;
+                key: z.ZodString;
+                store: z.ZodOptional<z.ZodString>;
+                operation: z.ZodOptional<z.ZodCustom<object, object>>;
+            }, z.core.$strict>], "source">>>;
+            selfSpawn: z.ZodOptional<z.ZodBoolean>;
+            ignoreFailure: z.ZodDefault<z.ZodBoolean>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    budget: z.ZodOptional<z.ZodObject<{
+        maxManagedProcesses: z.ZodOptional<z.ZodNumber>;
+        processStartConcurrency: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    supervision: z.ZodOptional<z.ZodObject<{
+        process: z.ZodOptional<z.ZodObject<{
+            baseDelayMs: z.ZodOptional<z.ZodNumber>;
+            factor: z.ZodOptional<z.ZodNumber>;
+            maxDelayMs: z.ZodOptional<z.ZodNumber>;
+            maxConsecutive: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        portForward: z.ZodOptional<z.ZodObject<{
+            baseDelayMs: z.ZodOptional<z.ZodNumber>;
+            factor: z.ZodOptional<z.ZodNumber>;
+            maxDelayMs: z.ZodOptional<z.ZodNumber>;
+            maxConsecutive: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        daemonModule: z.ZodOptional<z.ZodObject<{
+            baseDelayMs: z.ZodOptional<z.ZodNumber>;
+            factor: z.ZodOptional<z.ZodNumber>;
+            maxDelayMs: z.ZodOptional<z.ZodNumber>;
+            maxConsecutive: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        maxSpawnsPerMinute: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PMPluginConfig = z.infer<typeof PMPluginConfigSchema>;
+export interface PMGraph {
+    configs: ProcessConfig[];
+    /**
+     * The process list readers address (`configs` under its historical name).
+     * Always the same array as `configs`; kept defined so process-list readers
+     * never observe an absent field.
+     */
+    processes: ProcessConfig[];
+    resources: ResourceConfig[];
+    /** Presets with membership derived from each process's own `presets` field. */
+    presets: ProcessPreset[];
+    defaultPreset?: string;
+    /** The declared resource budget (`config.plugins.pm.budget`); empty when none is declared. */
+    budget: PMBudget;
+    /** Where the graph came from: `runtime:discovery`, `pm/process-source` and/or `config.plugins.pm`. */
+    sources: string[];
+    /** Process sources, or units of one, this read could not derive: their processes are absent from this read, every other process is present. */
+    sourceFailures: PMSourceFailure[];
+}
+/** A `pm/process-source` (and the unit, when the source names one) that could not be read, value-free. */
+export declare const PMSourceFailureSchema: z.ZodObject<{
+    source: z.ZodString;
+    unit: z.ZodOptional<z.ZodString>;
+    failure: z.ZodObject<{
+        name: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PMSourceFailure = z.infer<typeof PMSourceFailureSchema>;
+export interface PMGraphFilter {
+    /** Keep processes of this scope. */
+    scope?: ProcessConfig['scope'];
+    /** Keep processes and resources carrying any of these tags. */
+    tags?: string[];
+}
+//# sourceMappingURL=graph.d.ts.map

package/dist/schemas/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/schemas/graph.ts"],"names":[],"mappings":"AAAA,uJAAuJ;AAEvJ,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,OAAO,EAAyB,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc;;;kBAGzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;kBAKhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;kBAK9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGtB,CAAC;AACZ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,MAAM,WAAW,OAAO;IACvB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB;;;;OAIG;IACH,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,+EAA+E;IAC/E,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,8FAA8F;IAC9F,MAAM,EAAE,QAAQ,CAAC;IACjB,sGAAsG;IACtG,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,+IAA+I;IAC/I,cAAc,EAAE,eAAe,EAAE,CAAC;CAClC;AAED,0GAA0G;AAC1G,eAAO,MAAM,qBAAqB;;;;;;;;iBAIhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,MAAM,WAAW,aAAa;IAC7B,oCAAoC;IACpC,KAAK,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC/B,+DAA+D;IAC/D,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CAChB"}

package/dist/schemas/graph.js

@@ -0,0 +1,59 @@
+/** PM's graph contracts: the declared plugin config with its budget and supervision policies, the graph PM reads and the sources it could not read. */
+import * as z from 'zod/v4';
+import { ValueFreeFailureSchema } from '@vibesdotdev/kernel';
+import { ProcessManifestSchema } from "./process.js";
+/**
+ * PM's declared resource budget (map Unit H1): enforced, never advisory.
+ * - `maxManagedProcesses`: the most managed processes running or starting at
+ *   once in this admitted workspace. A NEW start past it is refused
+ *   `RATE_LIMITED` `pm-budget-max-processes`; running processes are never
+ *   stopped to honour a tightened budget.
+ * - `processStartConcurrency`: how many processes one preset batch starts at
+ *   once. It outranks a preset's own `maxProcessConcurrency` (it replaces the
+ *   old `PM_PROCESS_START_CONCURRENCY` env knob, pm.md S9).
+ */
+export const PMBudgetSchema = z.strictObject({
+    maxManagedProcesses: z.number().int().positive().optional(),
+    processStartConcurrency: z.number().int().positive().optional()
+});
+/**
+ * One supervised restart policy: attempt `n` waits `baseDelayMs * factor^(n-1)`,
+ * capped at `maxDelayMs`; after `maxConsecutive` consecutive failures the
+ * supervisor stops (absent: it keeps restarting).
+ */
+export const PMRestartPolicySchema = z.strictObject({
+    baseDelayMs: z.number().int().nonnegative().optional(),
+    factor: z.number().min(1).optional(),
+    maxDelayMs: z.number().int().positive().optional(),
+    maxConsecutive: z.number().int().nonnegative().optional()
+});
+/**
+ * PM's supervision policy (`config.plugins.pm.supervision`): how the daemon
+ * restarts what it owns. `process` and `portForward` restart crashed managed
+ * children (a process's own `restartDelay`/`maxRestarts` are its declared
+ * base and budget); `daemonModule` restarts the daemon's degraded required
+ * modules; `maxSpawnsPerMinute` is the runaway guard.
+ */
+export const PMSupervisionSchema = z.strictObject({
+    process: PMRestartPolicySchema.optional(),
+    portForward: PMRestartPolicySchema.optional(),
+    daemonModule: PMRestartPolicySchema.optional(),
+    maxSpawnsPerMinute: z.number().int().positive().optional()
+});
+/**
+ * `config.plugins.pm`: an inline manifest (processes, resources, presets,
+ * `defaultPreset`) plus the declared `budget` and `supervision`. Strict, so a key PM no longer
+ * reads (the retired `discoveryRoots`, moved to `package.json#workspaces`) is
+ * refused `plugin-config-invalid` naming it instead of being dropped.
+ */
+export const PMPluginConfigSchema = ProcessManifestSchema.extend({
+    budget: PMBudgetSchema.optional(),
+    supervision: PMSupervisionSchema.optional()
+}).strict();
+/** A `pm/process-source` (and the unit, when the source names one) that could not be read, value-free. */
+export const PMSourceFailureSchema = z.object({
+    source: z.string().min(1),
+    unit: z.string().min(1).optional(),
+    failure: ValueFreeFailureSchema
+});
+//# sourceMappingURL=graph.js.map

package/dist/schemas/graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../src/schemas/graph.ts"],"names":[],"mappings":"AAAA,uJAAuJ;AAEvJ,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAA0C,MAAM,cAAc,CAAC;AAG7F;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,YAAY,CAAC;IAC5C,mBAAmB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAC3D,uBAAuB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;CAC/D,CAAC,CAAC;AAGH;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,YAAY,CAAC;IACnD,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;IACtD,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACpC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAClD,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;CACzD,CAAC,CAAC;AAGH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,YAAY,CAAC;IACjD,OAAO,EAAE,qBAAqB,CAAC,QAAQ,EAAE;IACzC,WAAW,EAAE,qBAAqB,CAAC,QAAQ,EAAE;IAC7C,YAAY,EAAE,qBAAqB,CAAC,QAAQ,EAAE;IAC9C,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;CAC1D,CAAC,CAAC;AAGH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,qBAAqB,CAAC,MAAM,CAAC;IAChE,MAAM,EAAE,cAAc,CAAC,QAAQ,EAAE;IACjC,WAAW,EAAE,mBAAmB,CAAC,QAAQ,EAAE;CAC3C,CAAC,CAAC,MAAM,EAAE,CAAC;AAuBZ,0GAA0G;AAC1G,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACzB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IAClC,OAAO,EAAE,sBAAsB;CAC/B,CAAC,CAAC"}