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

package/dist/docs/pm.tasks.docs.descriptor.js

@@ -0,0 +1,242 @@
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'pm.tasks',
+    title: 'PM Tasks',
+    summary: 'Finite task processes: one-shot jobs, retries, and pass/fail gating',
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: `---
+title: PM Tasks
+summary: Finite task processes: one-shot jobs, retries, and pass/fail gating
+tags: [pm, tasks, process-manager, runOnce, lifecycle]
+parent: pm
+order: 2
+surfaces: [cli, web, in-app]
+hardware: [consumer]
+---
+
+PM manages long-running services *and* finite **task processes**. A task is a process
+that is expected to run to completion (a build step, a migration, a one-shot setup job)
+rather than stay up forever. Its exit code is mapped to a pass/fail status that other
+processes can depend on.
+
+PM is a **process manager** — there is no separate cron/interval/event scheduler. Tasks
+are ordinary \`ProcessConfig\` entries that opt into finite-run behavior with two flags:
+
+- \`task\` (builder: \`.taskMode()\`) — treat the process as a finite task; its exit code
+  maps to a \`pass\` / \`fail\` status instead of \`running\` / \`stopped\`.
+- \`runOnce\` (builder: \`.runOnce()\`) — run the process exactly once, then leave it in the
+  \`completed\` state instead of restarting it.
+
+## Task lifecycle states
+
+A finite task moves through the same \`ProcessState.status\` enum as any other process,
+but ends in a terminal task state:
+
+\`\`\`ts
+import type { ProcessState } from '@vibesdotdev/pm';
+
+// ProcessState.status is one of:
+type Status =
+	| 'starting'
+	| 'running'
+	| 'stopping'
+	| 'stopped'
+	| 'crashed'
+	| 'completed' // runOnce process finished
+	| 'waiting'   // blocked on requiresPass dependencies
+	| 'pass'      // taskMode process exited 0
+	| 'fail';     // taskMode process exited non-zero
+\`\`\`
+
+## Defining a task
+
+Use the \`defineProcess\` builder (or a raw \`ProcessConfig\`) and opt into task behavior.
+
+\`\`\`ts
+import { defineProcess } from '@vibesdotdev/pm';
+
+// A one-shot migration task that runs once and reports pass/fail.
+const migrate = defineProcess('db-migrate')
+	.name('Database Migration')
+	.command('bun', ['run', 'migrate'])
+	.cwd('/srv/app')
+	.taskMode()              // exit code -> pass/fail
+	.runOnce(true, true, 3)  // run once; retryOnFailure=true; maxRetries=3
+	.build();
+\`\`\`
+
+The equivalent raw \`ProcessConfig\` fields (all validated by \`ProcessConfigSchema\`):
+
+\`\`\`ts
+import type { ProcessConfig } from '@vibesdotdev/pm';
+
+const migrate: Partial<ProcessConfig> = {
+	id: 'db-migrate',
+	name: 'Database Migration',
+	command: 'bun',
+	args: ['run', 'migrate'],
+	cwd: '/srv/app',
+	task: true,            // finite task: exit code -> pass/fail
+	runOnce: true,         // run once, then stay 'completed'
+	retryOnFailure: true,  // retry a failed runOnce process
+	maxRetries: 3          // up to 3 retries (default 3)
+};
+\`\`\`
+
+## Gating processes on a task
+
+Other processes can refuse to start until a task has reached the \`pass\` state, using
+\`requiresPass\`. This makes tasks usable as ordered prerequisites (e.g. run migrations
+before booting the app server).
+
+\`\`\`ts
+import { defineProcess } from '@vibesdotdev/pm';
+
+const app = defineProcess('app-server')
+	.name('App Server')
+	.command('bun', ['run', 'start'])
+	.requiresPass('db-migrate') // waits in 'waiting' until db-migrate passes
+	.build();
+\`\`\`
+
+A process with unmet \`requiresPass\` dependencies sits in the \`waiting\` state. If a
+required task ends in \`fail\`, the dependent process is not started.
+
+## Running and inspecting tasks
+
+Tasks are started, listed, and inspected with the same CLI commands as any other PM
+process — there are no \`pm tasks ...\` subcommands.
+
+\`\`\`bash
+# Start a registered task by id
+vibes pm start db-migrate
+
+# Start and wait for it to finish (block until healthy/terminal)
+vibes pm start db-migrate --wait
+
+# List all processes (tasks show their pass/fail/completed status)
+vibes pm list
+
+# Show details for one process
+vibes pm show db-migrate
+
+# Tail its output
+vibes pm logs db-migrate
+\`\`\`
+
+## Programmatic API
+
+Resolve the PM client on the runtime your code was handed (a command's
+\`context.runtime\`, a tool's \`runtime\` argument) and drive processes through the
+\`IProcessManager\` interface. There is no \`registerTask\`/\`scheduleTask\` API — register a
+config, then start it.
+
+\`\`\`ts
+import { defineProcess } from '@vibesdotdev/pm';
+
+// \`runtime\`: the runtime handed to this code, never a process-wide default.
+const pm = await runtime.context('pm/client');
+
+const task = defineProcess('seed-data')
+	.name('Seed Data')
+	.command('bun', ['run', 'seed'])
+	.taskMode()
+	.runOnce()
+	.build();
+
+// Register the configuration, start it, then await the run's exit.
+await pm.register(task);
+const started = await pm.start(task);
+const exit = await pm.awaitExit('seed-data', { run: { startedAt: started.startedAt } });
+
+// status: 'pass' | 'fail' (taskMode), 'completed' (runOnce), 'stopped', 'crashed'
+const { status, succeeded, exitCode } = exit;
+
+// Later: query status without restarting.
+const current = await pm.getStatus('seed-data');
+\`\`\`
+
+Key \`IProcessManager\` methods relevant to tasks:
+
+- \`register(config)\` / \`unregister(id)\` — add or remove a process configuration.
+- \`start(config, { wait, timeout })\` / \`stop(id)\` / \`restart(id)\` — control execution.
+  \`wait\` waits for a declared health check (or socket) to answer, never for the
+  run to end: a task's \`start\` returns while it runs.
+- \`awaitExit(id, { run, timeoutMs, signal })\` — await a run's exit, PM's one
+  committed terminal record of that run (\`ProcessExit\`: \`status\`, \`succeeded\`,
+  \`exitCode\`, \`signal\`, \`pid\`). It is one \`await-exit\` call that ends on the
+  exit; nothing polls status. \`run\` (\`{ startedAt }\` from the \`start\` result)
+  pins the run: an earlier run's record never answers it and a later run refuses
+  \`pm-await-exit-run-superseded\`. \`succeeded\` is PM's: pass and completed
+  succeed, fail and crashed do not, and a stopped run succeeded only if it exited
+  0. Refusals: \`pm-process-state-not-found\`, \`pm-await-exit-timeout\`,
+  \`pm-await-exit-interrupted\` (the daemon went away and none answered again),
+  and \`wait-aborted\` on the caller's signal. When the daemon restarts or
+  publishes a new host generation mid-wait, the client re-issues for the same
+  run, so the wait still ends with the run's real exit.
+- \`getStatus(id)\` / \`getAllStatus()\` — read \`ProcessState\` (status, \`exitCode\`,
+  \`restartCount\`, \`retryCount\`).
+- \`getLogs(id, { lines, follow, stream })\` — read captured output.
+
+### Run one task to completion: \`runPmTask\`
+
+When the whole job is "run this and give me what happened", assemble none of that:
+\`@vibesdotdev/pm/tasks\` exports \`runPmTask(runtime, task, { runId, signal?, tags?, returnInterrupted? })\`,
+which starts (or attaches to) the process, awaits the run's exit, stops it on
+interruption, and returns its own captured \`stdout\`/\`stderr\` with the exit code
+PM recorded (\`null\` when PM observed none). The PM client is resolved through the
+runtime's \`pm/client\` context; a host without one refuses \`pm-client-unavailable\`.
+
+\`\`\`ts
+import { runPmTask } from '@vibesdotdev/pm/tasks';
+
+const result = await runPmTask(runtime, { command: 'bun', args: ['test'], timeoutMs: 120_000 }, { runId: job.id, tags: ['checks'] });
+// result: { processId, exitCode, stdout, stderr, termination?, pid? }
+\`\`\`
+
+A run that did not succeed refuses \`pm-task-failed\` (details: \`processId\`,
+\`exitCode\`, \`status\`) unless the task sets \`allowFailure\`; a deadline stops the
+process and refuses \`pm-task-timeout\` (a result with \`termination: 'timeout'\`
+under \`allowFailure\`); a cancelled caller signal stops the process and refuses
+\`pm-task-cancelled\`. A \`{ processId }\` target must be a declared process: a
+declared resource refuses \`pm-target-not-process\` before PM sets anything up.
+A supervised executor that must distinguish \`cancelled\` from \`timeout\` in its
+receipt passes \`returnInterrupted\` and receives the stopped run's output as a
+result. \`runbooks\`' \`ctx.command\` and external harness supervision delegate here.
+
+PM keeps an inline command's record (state, config, logs) after the run, for
+the dashboard and \`pm logs\`, until its ephemeral sweep. Read the retained terminal
+state with \`getStatus\`, configuration with \`getConfig\`, and output with
+\`getLogs\` or \`getLogsSince\` on the PM client. Process logs use the admitted
+workspace's \`<logDir>/workspaces/<toolingId>\`, independently of the daemon home.
+A caller that runs many
+tasks and keeps nothing PM holds sets \`retain: false\` on the command: once the
+run is over, returned or refused, PM removes the record through \`unregister\`.
+A \`{ processId }\` target is never removed. Diagnostics' command checks run this way.
+
+## Retry semantics
+
+\`retryOnFailure\` and \`maxRetries\` are declared on the process schema but PM
+does not implement them yet: a run's first committed terminal record is final,
+and \`awaitExit\` reports it. A caller that wants another attempt starts the
+task again. This is distinct from the service-restart budget (\`autoRestart\` /
+\`maxRestarts\` / \`restartSettleMs\`) used for long-running processes.
+
+:::card{title="See also"}
+- [\`pm.workers\`](pm.workers) — Long-running process lifecycle and health monitoring
+- [\`pm.preset\`](pm.preset) — Grouping processes and tasks into startable stacks
+- [\`pm.cli\`](pm.cli) — Full PM command reference
+:::
+`
+    },
+    parent: 'pm',
+    order: 2,
+    tags: ['pm', 'tasks', 'process-manager', 'runOnce', 'lifecycle'],
+    surfaces: ['cli', 'web', 'in-app'],
+    hardware: ['consumer'],
+    enabled: true
+};
+export default descriptor;
+//# sourceMappingURL=pm.tasks.docs.descriptor.js.map

package/dist/docs/pm.tasks.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pm.tasks.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/pm.tasks.docs.descriptor.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,GAAwB;IACvC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,UAAU;IACd,KAAK,EAAE,UAAU;IACjB,OAAO,EAAE,qEAAqE;IAC9E,IAAI,EAAE;QACL,IAAI,EAAE,UAAU;QAChB,UAAU,EAAE,KAAK;QACjB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+NT;KACC;IACD,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,WAAW,CAAC;IAChE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC;IAClC,QAAQ,EAAE,CAAC,UAAU,CAAC;IACtB,OAAO,EAAE,IAAI;CACb,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/pm.workers.docs.descriptor.d.ts

@@ -0,0 +1,4 @@
+import type { DocsTopicDescriptor } from '@vibesdotdev/docs-contracts';
+declare const descriptor: DocsTopicDescriptor;
+export default descriptor;
+//# sourceMappingURL=pm.workers.docs.descriptor.d.ts.map

package/dist/docs/pm.workers.docs.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pm.workers.docs.descriptor.d.ts","sourceRoot":"","sources":["../../src/docs/pm.workers.docs.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE,QAAA,MAAM,UAAU,EAAE,mBAwajB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/pm.workers.docs.descriptor.js

@@ -0,0 +1,427 @@
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'pm.workers',
+    title: 'PM Workers',
+    summary: 'Process manager workers, lifecycle management, and health monitoring',
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: `---
+title: PM Workers
+summary: Process manager workers, lifecycle management, and health monitoring
+tags: [pm, workers, process-manager, lifecycle, health, monitoring]
+parent: pm
+order: 1
+surfaces: [cli, web, in-app]
+hardware: [consumer]
+---
+
+The Process Manager (PM) workers system manages background process lifecycles, health monitoring, and automatic recovery for long-running services.
+
+## Worker architecture
+
+PM workers are **managed processes** with automatic lifecycle control:
+
+\`\`\`ts
+interface ProcessDescriptor {
+  id: string;                    // Unique process ID
+  name: string;                  // Human-readable name
+  command: string;               // Executable
+  args: string[];                // Command arguments
+  cwd: string;                   // Working directory
+  env: Record<string, string>;   // Environment variables
+  socket?: string;               // Unix socket path (for IPC)
+  healthCheck: HealthCheckConfig;
+  autoRestart: boolean;          // Auto-restart on crash
+  restartDelay: number;          // Delay between restarts (ms)
+  maxRestarts: number;           // Max restarts before giving up
+  tags: string[];                // Categorization tags
+}
+\`\`\`
+
+## Worker lifecycle
+
+### Starting workers
+
+\`\`\`ts
+import { getVibesClient } from '@vibesdotdev/kernel/client';
+import type { PMClient } from '@vibesdotdev/pm/client';
+
+// \`runtime\`: the runtime handed to this code (a command's \`context.runtime\`),
+// never a process-wide default.
+const pm = await getVibesClient<PMClient>('pm', runtime);
+
+// Start worker runtime
+await pm.start({
+  id: 'vibes-workers-consumer',
+  name: 'Local Worker Runtime (consumer)',
+  command: 'bun',
+  args: ['run', '--bun', 'vibes', 'workers', 'serve', 'consumer'],
+  cwd: '/Users/.../repository-collection',
+  env: {
+    VIBES_WORKER_TARGET: 'consumer',
+    VIBES_WORKER_SOCKET_PATH: '/Users/.../vibes-worker.sock'
+  },
+  socket: '/Users/.../vibes-worker.sock',
+  healthCheck: {
+    type: 'socket',
+    interval: 10000,      // Check every 10s
+    timeout: 5000,        // Timeout after 5s
+    retries: 3,           // Retry 3 times
+    warmupMs: 30000,      // Grace period: 30s
+    gracePeriodMultiplier: 6
+  },
+  autoRestart: true,
+  restartDelay: 3000,     // 3s delay
+  maxRestarts: 5,         // Max 5 restarts
+  tags: ['workers', 'local', 'ipc', 'consumer']
+});
+\`\`\`
+
+### Lifecycle states
+
+\`\`\`ts
+type ProcessStatus =
+  | 'running'      // Process is active and healthy
+  | 'stopped'      // Process was stopped intentionally
+  | 'crashed'      // Process exited with non-zero code
+  | 'starting'     // Process is launching
+  | 'stopping'     // Process is shutting down
+  | 'completed';   // Process exited successfully (code 0)
+\`\`\`
+
+### State transitions
+
+\`\`\`
+[stopped] --start--> [starting] --ready--> [running]
+   ^                       |                  |
+   |                       |                  |
+   |                    failed                | crash
+   |                       |                  |
+   |                       v                  v
+   |                  [crashed] <--auto-restart--
+   |                       |
+   |                    manual restart
+   |                       |
+   +-----------------------+
+   
+[running] --stop--> [stopping] --exit--> [stopped]
+\`\`\`
+
+## Health monitoring
+
+PM implements **multi-strategy health checks**:
+
+### Socket health check
+
+\`\`\`ts
+interface SocketHealthCheck {
+  type: 'socket';
+  socketPath: string;
+  interval: number;        // Check interval (ms)
+  timeout: number;         // Connection timeout (ms)
+  retries: number;         // Retries before unhealthy
+  warmupMs: number;        // Initial grace period
+  gracePeriodMultiplier: number;
+}
+
+// Implementation
+async function checkSocketHealth(socketPath: string): Promise<boolean> {
+  try {
+    await access(socketPath, constants.F_OK);
+    
+    const connected = await new Promise<boolean>((resolve) => {
+      const socket = connect(socketPath);
+      let settled = false;
+      
+      const finish = (ready: boolean) => {
+        if (settled) return;
+        settled = true;
+        socket.removeAllListeners();
+        socket.end();
+        resolve(ready);
+      };
+      
+      socket.once('connect', () => finish(true));
+      socket.once('error', () => finish(false));
+      socket.setTimeout(1000, () => {
+        socket.destroy();
+        finish(false);
+      });
+    });
+    
+    return connected;
+  } catch (error) {
+    // A failed probe is an unhealthy answer; the error is the reason to log.
+    return false;
+  }
+}
+\`\`\`
+
+### HTTP health check
+
+\`\`\`ts
+interface HTTPHealthCheck {
+  type: 'http';
+  url: string;
+  method: 'GET' | 'POST';
+  interval: number;
+  timeout: number;
+  expectedStatus: number;  // e.g. 200
+  warmupMs: number;
+}
+
+// Implementation
+async function checkHTTPHealth(url: string): Promise<boolean> {
+  try {
+    const response = await fetch(url, {
+      method: 'GET',
+      signal: AbortSignal.timeout(5000)
+    });
+    return response.status === 200;
+  } catch (error) {
+    // A failed probe is an unhealthy answer; the error is the reason to log.
+    return false;
+  }
+}
+\`\`\`
+
+### Process health check
+
+\`\`\`ts
+interface ProcessHealthCheck {
+  type: 'process';
+  pid: number;
+  interval: number;
+  warmupMs: number;
+}
+
+// Implementation
+function checkProcessHealth(pid: number): boolean {
+  try {
+    // Send signal 0 (doesn't kill, just checks existence)
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // ESRCH: no such process. EPERM: it exists, owned by another user.
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === 'ESRCH') return false;
+    if (code === 'EPERM') return true;
+    throw error;
+  }
+}
+\`\`\`
+
+## Automatic recovery
+
+PM implements **automatic restart with backoff**:
+
+\`\`\`ts
+class ProcessManager {
+  private restartCounts = new Map<string, number>();
+  
+  async handleCrash(processId: string): Promise<void> {
+    const process = this.processes.get(processId);
+    if (!process?.autoRestart) return;
+    
+    const restartCount = this.restartCounts.get(processId) || 0;
+    
+    if (restartCount >= process.maxRestarts) {
+      this.logger.error('Max restarts exceeded', { processId });
+      await this.markAsFailed(processId);
+      return;
+    }
+    
+    // Exponential backoff: delay * 2^restartCount
+    const delay = process.restartDelay * Math.pow(2, restartCount);
+    
+    this.logger.info('Restarting process', {
+      processId,
+      restartCount: restartCount + 1,
+      delayMs: delay
+    });
+    
+    // A tracked pause on the runtime lifecycle (RC07); it ends with the runtime.
+    await runtime.lifecycle.delay(delay);
+    await this.start(process);
+    this.restartCounts.set(processId, restartCount + 1);
+  }
+}
+\`\`\`
+
+## Worker status API
+
+### Get process status
+
+\`\`\`ts
+const status = await pm.getStatus('vibes-workers-consumer');
+// {
+//   id: 'vibes-workers-consumer',
+//   name: 'Local Worker Runtime (consumer)',
+//   status: 'running',
+//   pid: 12345,
+//   health: 'healthy',
+//   restartCount: 0,
+//   socketPath: '/Users/.../vibes-worker.sock',
+//   uptimeMs: 3600000
+// }
+\`\`\`
+
+### List all workers
+
+\`\`\`ts
+const workers = await pm.list();
+// [
+//   {
+//     id: 'vibes-workers-consumer',
+//     name: 'Local Worker Runtime',
+//     status: 'running',
+//     health: 'healthy'
+//   },
+//   {
+//     id: 'vibes-bridge-daemon',
+//     name: 'Bridge Daemon',
+//     status: 'running',
+//     health: 'healthy'
+//   }
+// ]
+\`\`\`
+
+### Health monitoring
+
+\`\`\`ts
+// Poll all process statuses to observe health changes
+const statuses = await pm.getAllStatus();
+for (const status of statuses) {
+  console.log(\`Process \${status.id}: \${status.health}\`);
+}
+\`\`\`
+
+## CLI commands
+
+\`\`\`bash
+# Start worker
+vibes pm start vibes-workers-consumer
+
+# Stop worker
+vibes pm stop vibes-workers-consumer
+
+# Restart worker
+vibes pm restart vibes-workers-consumer
+
+# Get status
+vibes pm status vibes-workers-consumer
+
+# List all workers
+vibes pm list
+
+# View logs
+vibes pm logs vibes-workers-consumer
+
+# Follow logs
+vibes pm logs vibes-workers-consumer --follow
+\`\`\`
+
+## Error handling
+
+### Graceful shutdown
+
+\`\`\`ts
+async function gracefulStop(processId: string, timeoutMs = 10000): Promise<void> {
+  const process = this.processes.get(processId);
+  if (!process) return;
+  
+  // Send SIGTERM
+  process.kill('SIGTERM');
+  
+  // Wait for graceful shutdown: a lifecycle-bounded wait (RC07), never a sleep loop.
+  if (await waitForProcessExit(runtime, process.pid, timeoutMs)) {
+    return;  // Exited gracefully
+  }
+  
+  // Force kill
+  process.kill('SIGKILL');
+}
+\`\`\`
+
+### Crash detection
+
+\`\`\`ts
+process.on('exit', (code, signal) => {
+  if (code !== 0 || signal !== null) {
+    // Process crashed
+    this.handleCrash(process.id);
+  }
+});
+
+process.on('error', (error) => {
+  this.logger.error('Process error', {
+    processId: process.id,
+    error: error.message
+  });
+});
+\`\`\`
+
+## Resource management
+
+### Process tree cleanup
+
+\`\`\`ts
+// pm/src/helpers/graceful-kill-tree.ts
+import { execSync } from 'node:child_process';
+
+export async function gracefulKillTree(pid: number): Promise<void> {
+  // Get child processes
+  const children = execSync(\`pgrep -P \${pid}\`, { encoding: 'utf8' })
+    .split('\\n')
+    .filter(Boolean)
+    .map(Number);
+  
+  // Kill children first
+  await Promise.all(
+    children.map(child => gracefulKillTree(child))
+  );
+  
+  // Kill parent
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (error) {
+    // ESRCH: already dead. Anything else (EPERM) is a real failure.
+    if ((error as NodeJS.ErrnoException).code !== 'ESRCH') throw error;
+  }
+}
+\`\`\`
+
+### Socket cleanup
+
+\`\`\`ts
+// pm/src/helpers/socket-paths.ts
+import { unlink } from 'node:fs/promises';
+
+export async function cleanupSocket(socketPath: string): Promise<void> {
+  try {
+    await unlink(socketPath);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+      throw error;
+    }
+  }
+}
+\`\`\`
+
+:::card{title="See also"}
+- [\`pm.tasks\`](pm.tasks) — Task scheduling
+- [\`pm.queues\`](pm.queues) — Queue management
+- [\`workers.kinds\`](workers.kinds) — Worker kinds
+:::
+`
+    },
+    parent: 'pm',
+    order: 1,
+    tags: ['pm', 'workers', 'process-manager', 'lifecycle', 'health', 'monitoring'],
+    surfaces: ['cli', 'web', 'in-app'],
+    hardware: ['consumer'],
+    enabled: true
+};
+export default descriptor;
+//# sourceMappingURL=pm.workers.docs.descriptor.js.map

package/dist/docs/pm.workers.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pm.workers.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/pm.workers.docs.descriptor.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,GAAwB;IACvC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,YAAY;IAChB,KAAK,EAAE,YAAY;IACnB,OAAO,EAAE,sEAAsE;IAC/E,IAAI,EAAE;QACL,IAAI,EAAE,UAAU;QAChB,UAAU,EAAE,KAAK;QACjB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwZT;KACC;IACD,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,iBAAiB,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,CAAC;IAC/E,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC;IAClC,QAAQ,EAAE,CAAC,UAAU,CAAC;IACtB,OAAO,EAAE,IAAI;CACb,CAAC;AAEF,eAAe,UAAU,CAAC"}