@kb-labs/workflow-daemon 2.112.0 → 2.116.11

package/dist/index.js

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
-import { platform, createServiceBootstrap } from '@kb-labs/core-runtime';
 import { makeAssemblyHook } from '@kb-labs/plugin-runtime';
 import { WorkflowEngine, WorkflowService } from '@kb-labs/workflow-engine';
-import { createCorrelatedLogger, getListenOptions, HttpObservabilityCollector, createDaemonServer, createServiceReadyResponse, metricLine } from '@kb-labs/shared-http';
-import { runDaemon } from '@kb-labs/shared-daemon';
-import { logDiagnosticEvent } from '@kb-labs/core-platform';
+import { getListenOptions, HttpObservabilityCollector, createDaemonServer, createServiceReadyResponse, metricLine } from '@kb-labs/shared-http';
+import { runService } from '@kb-labs/shared-daemon';
+import { logDiagnosticEvent, createContextLogger } from '@kb-labs/core-platform';
 import { PluginCronJobSchema, UserCronJobSchema, evaluateExpression, interpolateObject, buildShellSafeCommand, coerceToString, interpolateString } from '@kb-labs/workflow-contracts';
 import { GateHandler } from '@kb-labs/workflow-steps';
 import { SandboxRunner } from '@kb-labs/workflow-runtime';
@@ -22,14 +21,14 @@ async function createWorkflowWorker(options) {
     engine,
     cliApi,
     logger,
-    platform: platform2,
+    platform,
     workspaceRoot,
     concurrency = 5,
     defaultTimeout = 12e4,
     analytics,
     debugMode = process.env["WORKFLOW_DEBUG"] === "true"
   } = options;
-  const wsProvider = platform2.getAdapter("workspace");
+  const wsProvider = platform.getAdapter("workspace");
   if (wsProvider && typeof wsProvider.startupCleanup === "function") {
     wsProvider.startupCleanup().catch(() => {
     });
@@ -38,7 +37,7 @@ async function createWorkflowWorker(options) {
   let stopRequested = false;
   const runningJobs = /* @__PURE__ */ new Map();
   const claimedJobs = /* @__PURE__ */ new Set();
-  const executionBackend = platform2.executionBackend;
+  const executionBackend = platform.executionBackend;
   const runner = new SandboxRunner({
     // IExecutionBackend<unknown> (core-contracts) is structurally compatible with
     // ExecutionBackend (plugin-execution) — both expose the same execute/health/stats/shutdown API.
@@ -54,10 +53,14 @@ async function createWorkflowWorker(options) {
     }
     const run = await engine.getRun(entry.runId);
     if (!run) {
-      logger.error("Data inconsistency: Run not found for job entry", void 0, {
-        runId: entry.runId,
-        jobId: entry.jobId
-      });
+      logger.error(
+        "Data inconsistency: Run not found for job entry",
+        void 0,
+        {
+          runId: entry.runId,
+          jobId: entry.jobId
+        }
+      );
       return true;
     }
     const job = run.jobs.find((j) => j.id === entry.jobId);
@@ -82,20 +85,19 @@ async function createWorkflowWorker(options) {
       waitMs
     });
     const jobStartTime = Date.now();
-    const jobLogger = createCorrelatedLogger(logger, {
+    const jobLogger = createContextLogger(logger, {
+      applicationId: "workflow-daemon",
       serviceId: "workflow",
-      logsSource: "workflow",
-      layer: "workflow",
-      service: "worker",
+      instanceId: `${process.pid}`,
+      layer: "service"
+    }).forComponent("workflow-worker").forOperation("workflow.job", {
       requestId: run.id,
-      traceId: run.id,
-      operation: "workflow.job",
-      bindings: {
-        workflowId: run.id,
-        runId: run.id,
-        jobId: job.id,
-        jobName: job.jobName
-      }
+      traceId: run.id
+    }).with({
+      "workflow.id": run.id,
+      "workflow.run_id": run.id,
+      "workflow.job_id": job.id,
+      "workflow.job_name": job.jobName
     });
     jobLogger.info("Processing job", {
       runId: run.id,
@@ -113,7 +115,7 @@ async function createWorkflowWorker(options) {
     const runTarget = run.metadata?.target;
     const jobTarget = job.target;
     const target = jobTarget ?? runTarget;
-    const wsProvider2 = platform2.getAdapter("workspace");
+    const wsProvider2 = platform.getAdapter("workspace");
     let runWorkspace = wsProvider2 ? workspaceRoot : process.env["KB_PROJECT_ROOT"] ?? workspaceRoot;
     let provisionedWorkspaceId;
     if (wsProvider2) {
@@ -220,7 +222,9 @@ async function createWorkflowWorker(options) {
                   env: exprCtx.env
                 }
               });
-              await engine.markStepCompleted(run.id, job.id, step.id, { skipped: true });
+              await engine.markStepCompleted(run.id, job.id, step.id, {
+                skipped: true
+              });
               continue;
             }
           }
@@ -237,7 +241,10 @@ async function createWorkflowWorker(options) {
               }
             });
           }
-          let interpolatedWith = step.spec.with ? interpolateObject(step.spec.with, exprCtx) : void 0;
+          let interpolatedWith = step.spec.with ? interpolateObject(
+            step.spec.with,
+            exprCtx
+          ) : void 0;
           if (step.spec.uses === "builtin:shell" && typeof step.spec.with?.["command"] === "string") {
             const rawCommand = step.spec.with["command"];
             const { command: safeCommand, shellEnvVars } = buildShellSafeCommand(rawCommand, exprCtx);
@@ -246,15 +253,23 @@ async function createWorkflowWorker(options) {
               command: safeCommand,
               env: {
                 ...Object.fromEntries(
-                  Object.entries(interpolatedWith?.["env"] ?? {}).map(([k, v]) => [k, coerceToString(v)])
+                  Object.entries(
+                    interpolatedWith?.["env"] ?? {}
+                  ).map(([k, v]) => [k, coerceToString(v)])
                 ),
                 ...shellEnvVars
               }
             };
           }
-          const interpolatedEnvRaw = step.spec.env ? interpolateObject(step.spec.env, exprCtx) : void 0;
+          const interpolatedEnvRaw = step.spec.env ? interpolateObject(
+            step.spec.env,
+            exprCtx
+          ) : void 0;
           const interpolatedEnv = interpolatedEnvRaw ? Object.fromEntries(
-            Object.entries(interpolatedEnvRaw).map(([k, v]) => [k, coerceToString(v)])
+            Object.entries(interpolatedEnvRaw).map(([k, v]) => [
+              k,
+              coerceToString(v)
+            ])
           ) : void 0;
           if (debugMode && step.spec.with) {
             jobLogger.info("[debug] Step input interpolation", {
@@ -294,7 +309,10 @@ async function createWorkflowWorker(options) {
           });
           if (step.spec.uses === "builtin:approval") {
             if (step.status === "failed") {
-              stepLogger.info("Approval already rejected \u2014 skipping to gate", { runId: run.id, stepId: step.id });
+              stepLogger.info("Approval already rejected \u2014 skipping to gate", {
+                runId: run.id,
+                stepId: step.id
+              });
               continue;
             }
             if (step.status !== "waiting_approval") {
@@ -318,11 +336,18 @@ async function createWorkflowWorker(options) {
             const gateInput = interpolatedWith ?? {};
             const currentIteration = step.metadata?.["iterations"] ?? 0;
             const sameJobStepIds = job.steps.flatMap(
-              (s) => [s.id, s.spec.id].filter((v) => typeof v === "string")
+              (s) => [s.id, s.spec.id].filter(
+                (v) => typeof v === "string"
+              )
             );
             const jobNames = (freshRun?.jobs ?? run.jobs).map((j) => j.jobName);
             const validRestartTargets = [...sameJobStepIds, ...jobNames];
-            const decision = new GateHandler().handle(gateInput, exprCtx, currentIteration, validRestartTargets);
+            const decision = new GateHandler().handle(
+              gateInput,
+              exprCtx,
+              currentIteration,
+              validRestartTargets
+            );
             stepLogger.info("[gate] Evaluating gate decision", {
               runId: run.id,
               stepId: step.id,
@@ -332,23 +357,45 @@ async function createWorkflowWorker(options) {
               iteration: currentIteration
             });
             if (decision.action === "continue") {
-              await engine.markStepCompleted(run.id, job.id, step.id, decision.outputs);
+              await engine.markStepCompleted(
+                run.id,
+                job.id,
+                step.id,
+                decision.outputs
+              );
               continue;
             }
             if (decision.action === "fail") {
-              stepLogger.error("[gate] Gate condition failed, aborting job", decision.error, {
-                runId: run.id,
-                stepId: step.id,
-                stepName: step.name
-              });
-              await engine.markStepFailed(run.id, job.id, step.id, decision.error, decision.outputs);
+              stepLogger.error(
+                "[gate] Gate condition failed, aborting job",
+                decision.error,
+                {
+                  runId: run.id,
+                  stepId: step.id,
+                  stepName: step.name
+                }
+              );
+              await engine.markStepFailed(
+                run.id,
+                job.id,
+                step.id,
+                decision.error,
+                decision.outputs
+              );
               throw decision.error;
             }
             if (decision.action === "skip") {
               await applyGateSkip(engine, run, job, step, decision, stepLogger);
               return;
             }
-            await applyGateRestart(engine, run, job, step, decision, stepLogger);
+            await applyGateRestart(
+              engine,
+              run,
+              job,
+              step,
+              decision,
+              stepLogger
+            );
             return;
           }
           const stepStartTime = Date.now();
@@ -360,20 +407,41 @@ async function createWorkflowWorker(options) {
             baseSpec = {
               ...rest,
               uses: "builtin:shell",
-              with: { ...existingWith, command, env: { ...existingWith?.["env"] ?? {}, ...shellEnvVars } }
+              with: {
+                ...existingWith,
+                command,
+                env: {
+                  ...existingWith?.["env"] ?? {},
+                  ...shellEnvVars
+                }
+              }
             };
           }
           if (typeof baseSpec.summary === "string") {
             baseSpec.summary = interpolateString(baseSpec.summary, exprCtx);
           }
-          const specWithEnv = interpolatedEnv ? { ...baseSpec, with: { ...baseSpec.with ?? {}, env: { ...baseSpec.with?.["env"] ?? {}, ...interpolatedEnv } } } : baseSpec;
+          const specWithEnv = interpolatedEnv ? {
+            ...baseSpec,
+            with: {
+              ...baseSpec.with ?? {},
+              env: {
+                ...baseSpec.with?.["env"] ?? {},
+                ...interpolatedEnv
+              }
+            }
+          } : baseSpec;
           const interpolatedSpec = interpolatedWith ? {
             ...specWithEnv,
             with: {
               ...specWithEnv.with ?? {},
               ...interpolatedWith,
               // spec.env (interpolatedEnv) must survive the spread of interpolatedWith.env
-              ...interpolatedEnv ? { env: { ...interpolatedWith["env"] ?? {}, ...interpolatedEnv } } : {}
+              ...interpolatedEnv ? {
+                env: {
+                  ...interpolatedWith["env"] ?? {},
+                  ...interpolatedEnv
+                }
+              } : {}
             }
           } : specWithEnv;
           const result = await runner.execute({
@@ -398,7 +466,10 @@ async function createWorkflowWorker(options) {
               secrets: (() => {
                 const names = freshRun?.secrets ?? [];
                 if (names.length > 0) {
-                  stepLogger.warn("Step declares secrets but secret resolution is not implemented", { secrets: names });
+                  stepLogger.warn(
+                    "Step declares secrets but secret resolution is not implemented",
+                    { secrets: names }
+                  );
                 }
                 return {};
               })(),
@@ -425,12 +496,24 @@ async function createWorkflowWorker(options) {
                   lineNo: entry2.lineNo,
                   logSource: entry2.stream === "stderr" ? "stderr" : "stdout"
                 });
-                void engine.publishLog(run.id, job.id, step.id, entry2, step.name);
+                void engine.publishLog(
+                  run.id,
+                  job.id,
+                  step.id,
+                  entry2,
+                  step.name
+                );
               },
               // ctx.logger.* entries: stepLogger base already wrote to SQLite. Only publish for SSE.
               // See: plugins/workflow/docs/adr/0019-log-stream-separation.md
               onLoggerLog: (entry2) => {
-                void engine.publishLog(run.id, job.id, step.id, entry2, step.name);
+                void engine.publishLog(
+                  run.id,
+                  job.id,
+                  step.id,
+                  entry2,
+                  step.name
+                );
               }
             },
             // Scripts (.kb/workflows/scripts/*.sh) live in the project root, not the worktree.
@@ -442,7 +525,9 @@ async function createWorkflowWorker(options) {
           });
           if (result.status === "failed") {
             const stepDurationMs = Date.now() - stepStartTime;
-            const error = new Error(result.error?.message ?? "Step execution failed");
+            const error = new Error(
+              result.error?.message ?? "Step execution failed"
+            );
             await engine.markStepFailed(run.id, job.id, step.id, error);
             failedStepFailure = result.failure;
             failedStepRetry = step.spec.retry;
@@ -457,11 +542,14 @@ async function createWorkflowWorker(options) {
               errorCode: result.error?.code
             });
             if (step.continueOnError) {
-              stepLogger.warn("[step] continueOnError=true \u2014 continuing despite failure", {
-                runId: run.id,
-                jobId: job.id,
-                stepId: step.id
-              });
+              stepLogger.warn(
+                "[step] continueOnError=true \u2014 continuing despite failure",
+                {
+                  runId: run.id,
+                  jobId: job.id,
+                  stepId: step.id
+                }
+              );
               continue;
             }
             throw error;
@@ -507,7 +595,9 @@ async function createWorkflowWorker(options) {
         if (provisionedWorkspaceId && wsProvider2) {
           try {
             await wsProvider2.release(provisionedWorkspaceId);
-            jobLogger.info("Workspace released", { workspaceId: provisionedWorkspaceId });
+            jobLogger.info("Workspace released", {
+              workspaceId: provisionedWorkspaceId
+            });
           } catch (releaseErr) {
             jobLogger.warn("Workspace release failed", {
               workspaceId: provisionedWorkspaceId,
@@ -519,7 +609,13 @@ async function createWorkflowWorker(options) {
         const err = error instanceof Error ? error : new Error(String(error));
         const jobDuration = Date.now() - jobStartTime;
         const retryPolicy = failedStepRetry ?? job.retries;
-        await engine.markJobFailed(run.id, job.id, err, failedStepFailure, retryPolicy);
+        await engine.markJobFailed(
+          run.id,
+          job.id,
+          err,
+          failedStepFailure,
+          retryPolicy
+        );
         analytics?.track("workflow.worker.job.failed", {
           runId: run.id,
           jobId: job.id,
@@ -612,9 +708,12 @@ async function createWorkflowWorker(options) {
             sleep(shutdownTimeoutMs)
           ]);
           if (runningJobs.size > 0) {
-            logger.warn("Shutdown timeout reached, marking jobs as interrupted", {
-              count: runningJobs.size
-            });
+            logger.warn(
+              "Shutdown timeout reached, marking jobs as interrupted",
+              {
+                count: runningJobs.size
+              }
+            );
             await Promise.all(
               Array.from(runningJobs.keys()).map(async (jobKey) => {
                 const [runId, jobId] = jobKey.split(":");
@@ -627,9 +726,13 @@ async function createWorkflowWorker(options) {
             logger.info("All in-flight jobs completed gracefully");
           }
         } catch (error) {
-          logger.error("Error during graceful shutdown", error instanceof Error ? error : void 0, {
-            runningJobsCount: runningJobs.size
-          });
+          logger.error(
+            "Error during graceful shutdown",
+            error instanceof Error ? error : void 0,
+            {
+              runningJobsCount: runningJobs.size
+            }
+          );
         }
       }
       logger.info("Workflow worker stopped");
@@ -649,12 +752,15 @@ function sleep(ms) {
 async function waitForApproval(engine, runId, jobId, step, interpolatedWith, isStopRequested, stepLogger) {
   const approvalTimeoutMs = interpolatedWith?.["timeoutMs"];
   if (!approvalTimeoutMs) {
-    stepLogger.warn("[approval] No timeout configured \u2014 approval may wait indefinitely", {
-      runId,
-      jobId,
-      stepId: step.id,
-      stepName: step.name
-    });
+    stepLogger.warn(
+      "[approval] No timeout configured \u2014 approval may wait indefinitely",
+      {
+        runId,
+        jobId,
+        stepId: step.id,
+        stepName: step.name
+      }
+    );
   }
   stepLogger.info("[approval] Waiting for approval", {
     runId,
@@ -670,12 +776,15 @@ async function waitForApproval(engine, runId, jobId, step, interpolatedWith, isS
     pollCount++;
     const currentRun = await engine.getRun(runId);
     if (currentRun?.status === "cancelled") {
-      stepLogger.info("[approval] Run cancelled \u2014 treating as interrupted, NOT approved", {
-        runId,
-        stepId: step.id,
-        stepName: step.name,
-        waitedMs: Date.now() - approvalStartMs
-      });
+      stepLogger.info(
+        "[approval] Run cancelled \u2014 treating as interrupted, NOT approved",
+        {
+          runId,
+          stepId: step.id,
+          stepName: step.name,
+          waitedMs: Date.now() - approvalStartMs
+        }
+      );
       return "interrupted";
     }
     const currentJob = currentRun?.jobs.find((j) => j.id === jobId);
@@ -709,7 +818,9 @@ async function waitForApproval(engine, runId, jobId, step, interpolatedWith, isS
     }
   }
   if (isStopRequested()) {
-    stepLogger.info("Approval wait interrupted by shutdown", { stepId: step.id });
+    stepLogger.info("Approval wait interrupted by shutdown", {
+      stepId: step.id
+    });
     return "interrupted";
   }
   return "done";
@@ -785,7 +896,9 @@ async function applyGateRestart(engine, run, job, step, decision, stepLogger) {
       return draft;
     });
   }
-  const sameJobTarget = job.steps.some((s) => s.spec.id === restartFrom || s.id === restartFrom);
+  const sameJobTarget = job.steps.some(
+    (s) => s.spec.id === restartFrom || s.id === restartFrom
+  );
   if (!sameJobTarget) {
     const fresh = await engine.getRun(run.id) ?? run;
     const resetNames = /* @__PURE__ */ new Set([restartFrom]);
@@ -827,7 +940,11 @@ async function applyGateRestart(engine, run, job, step, decision, stepLogger) {
     const refreshed = await engine.getRun(run.id);
     const targetJob = refreshed?.jobs.find((j) => j.jobName === restartFrom);
     if (targetJob && !targetJob.blocked) {
-      await scheduler.enqueueJob(run.id, targetJob, targetJob.priority ?? "normal");
+      await scheduler.enqueueJob(
+        run.id,
+        targetJob,
+        targetJob.priority ?? "normal"
+      );
     }
     stepLogger.warn("[gate] Cross-job restart re-enqueued target", {
       runId: run.id,
@@ -861,7 +978,11 @@ async function applyGateRestart(engine, run, job, step, decision, stepLogger) {
   const updatedRun = await engine.getRun(run.id);
   const updatedJob = updatedRun?.jobs.find((j) => j.id === job.id);
   if (updatedJob) {
-    await scheduler.enqueueJob(run.id, updatedJob, updatedJob.priority ?? "normal");
+    await scheduler.enqueueJob(
+      run.id,
+      updatedJob,
+      updatedJob.priority ?? "normal"
+    );
     stepLogger.info("[gate] Job re-enqueued for restart", {
       runId: run.id,
       jobId: job.id,
@@ -877,10 +998,10 @@ function inferWorkspaceProvisionReasonCode(message) {
 
 // src/job-broker.ts
 var JobBroker = class {
-  constructor(engine, logger, platform2) {
+  constructor(engine, logger, platform) {
     this.engine = engine;
     this.logger = logger;
-    this.platform = platform2;
+    this.platform = platform;
   }
   engine;
   logger;
@@ -3050,169 +3171,180 @@ function buildWorkflowMetricLines(metrics) {
   ];
 }
 async function bootstrap(_cwd = process.cwd()) {
-  await runDaemon(
-    {
-      appId: "workflow-daemon",
-      // serviceId in the transport map / devservices is 'workflow' (≠ appId).
-      serviceId: "workflow",
-      defaultPort: 7778,
-      portEnvVar: "WORKFLOW_PORT",
-      defaultHost: "0.0.0.0",
-      hostEnvVar: "WORKFLOW_HOST",
-      async setup({ platform: _p, logger: _l, port, host, repoRoot }) {
-        const projectRoot = process.env["KB_PROJECT_ROOT"] ?? repoRoot;
-        if (!platform.isConfigured("workspace")) {
-          process.stderr.write(
-            '[workflow-daemon] WARNING: workspace adapter is not configured.\n[workflow-daemon] Workflows that use isolation: balanced (default) or isolation: strict will fail.\n[workflow-daemon] To fix: set platform.adapters.workspace in kb.config.json.\n[workflow-daemon] To run without a workspace: add "isolation: relaxed" to your workflow YAML.\n'
-          );
-        }
-        if (!platform.isConfigured("environment") && platform.isConfigured("workspace")) {
-          process.stderr.write(
-            "[workflow-daemon] WARNING: environment adapter is not configured.\n[workflow-daemon] Workflows that use isolation: strict will fail.\n[workflow-daemon] To fix: set platform.adapters.environment in kb.config.json.\n"
-          );
-        }
-        const startupRequestId = `workflow-startup-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-        const startupTraceId = randomUUID();
-        const startupSpanId = randomUUID();
-        const bootstrapLogger = createCorrelatedLogger(platform.logger, {
-          serviceId: "workflow",
-          logsSource: "workflow",
-          layer: "workflow",
-          service: "bootstrap",
-          requestId: startupRequestId,
-          traceId: startupTraceId,
-          operation: "workflow.bootstrap",
-          bindings: { spanId: startupSpanId, invocationId: startupSpanId, executionId: startupSpanId }
-        });
-        const debugMode = process.env["WORKFLOW_DEBUG"] === "true";
-        bootstrapLogger.info("Workflow daemon starting", { projectRoot, debugMode });
-        if (debugMode) {
-          bootstrapLogger.warn(
-            "[WORKFLOW_DEBUG=true] Verbose debug logging is ON \u2014 step inputs, outputs, and expr contexts will be logged. Disable in production (unset WORKFLOW_DEBUG or set to false)."
-          );
-        }
-        const createWorkflowLogger = (service, operation, bindings) => createCorrelatedLogger(platform.logger, {
-          serviceId: "workflow",
-          logsSource: "workflow",
-          layer: "workflow",
-          service,
-          operation,
-          bindings
-        });
-        bootstrapLogger.info("Loading plugin registry snapshot");
-        const cliApi = await createRegistry({ root: repoRoot, cache: { ttlMs: 10 * 60 * 1e3 } });
-        await cliApi.initialize();
-        const plugins = await cliApi.listPlugins();
-        bootstrapLogger.info("Plugin registry snapshot loaded", {
-          pluginsFound: plugins.length,
-          pluginIds: plugins.map((p) => `${p.id}@${p.version}`)
-        });
-        bootstrapLogger.info("Creating WorkflowEngine");
-        const engine = new WorkflowEngine({
-          cache: platform.cache,
-          events: platform.eventBus,
-          logger: createWorkflowLogger("engine", "workflow.engine"),
-          snapshotManager: platform.snapshotManager,
-          workspaceRoot: projectRoot
-        });
-        bootstrapLogger.info("Cleaning up stale runs from previous daemon process");
-        await engine.cleanupStaleRuns();
-        bootstrapLogger.info("Resuming interrupted jobs");
-        await engine.resumeInterruptedJobs();
-        bootstrapLogger.info("Creating JobBroker");
-        const jobBroker = new JobBroker(
-          engine,
-          createWorkflowLogger("job-broker", "workflow.job-broker"),
-          platform
-        );
-        bootstrapLogger.info("Creating CronScheduler");
-        const cronScheduler = new CronScheduler({
-          jobBroker,
-          workflowEngine: engine,
-          logger: createWorkflowLogger("cron-scheduler", "workflow.cron-scheduler"),
-          timezone: process.env.WORKFLOW_CRON_TIMEZONE
+  await runService({
+    appId: "workflow-daemon",
+    startDir: _cwd,
+    // serviceId in the transport map / devservices is 'workflow' (≠ appId).
+    serviceId: "workflow",
+    defaultPort: 7778,
+    portEnvVar: "WORKFLOW_PORT",
+    defaultHost: "0.0.0.0",
+    hostEnvVar: "WORKFLOW_HOST",
+    platform: {
+      assemblyHook: makeAssemblyHook()
+    },
+    async setup({
+      platform,
+      port,
+      host,
+      projectRoot,
+      platformRoot,
+      logger: serviceLogger
+    }) {
+      const workspaceRoot = process.env["KB_PROJECT_ROOT"] ?? projectRoot;
+      const startupRequestId = `workflow-startup-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+      const startupTraceId = randomUUID();
+      const startupSpanId = randomUUID();
+      const bootstrapLogger = serviceLogger.forComponent("workflow-bootstrap").forOperation("workflow.bootstrap", {
+        requestId: startupRequestId,
+        traceId: startupTraceId,
+        spanId: startupSpanId
+      }).with({ invocationId: startupSpanId, executionId: startupSpanId });
+      if (!platform.isConfigured("workspace")) {
+        bootstrapLogger.warn("Workspace adapter is not configured", {
+          impact: "Workflows using balanced or strict isolation will fail.",
+          remediation: "Configure platform.adapters.workspace or use relaxed isolation."
         });
-        bootstrapLogger.info("Discovering cron jobs");
-        const cronDiscovery = new CronDiscovery({
-          cliApi,
-          scheduler: cronScheduler,
-          logger: createWorkflowLogger("cron-discovery", "workflow.cron-discovery"),
-          workspaceRoot: projectRoot
+      }
+      if (!platform.isConfigured("environment") && platform.isConfigured("workspace")) {
+        bootstrapLogger.warn("Environment adapter is not configured", {
+          impact: "Workflows using strict isolation will fail.",
+          remediation: "Configure platform.adapters.environment."
         });
-        const discovered = await cronDiscovery.discoverAll();
-        bootstrapLogger.info("Cron job discovery complete", discovered);
-        bootstrapLogger.info("Creating WorkflowService");
-        const workflowService = new WorkflowService({ cliApi, platform, workspaceRoot: projectRoot });
-        workflowService.listAll().catch(
-          (err) => bootstrapLogger.warn("Manifest scanner warmup failed", { err })
+      }
+      const debugMode = process.env["WORKFLOW_DEBUG"] === "true";
+      bootstrapLogger.info("Workflow daemon starting", {
+        projectRoot: workspaceRoot,
+        debugMode
+      });
+      if (debugMode) {
+        bootstrapLogger.warn(
+          "[WORKFLOW_DEBUG=true] Verbose debug logging is ON \u2014 step inputs, outputs, and expr contexts will be logged. Disable in production (unset WORKFLOW_DEBUG or set to false)."
         );
-        bootstrapLogger.info("Starting WorkflowFileWatcher");
-        const fileWatcher = new WorkflowFileWatcher({
-          watchDirs: [
-            join(projectRoot, ".kb", "workflows"),
-            join(projectRoot, ".kb", "jobs")
-          ],
-          workflowService,
-          cronDiscovery,
-          cronScheduler,
-          logger: createWorkflowLogger("file-watcher", "workflow.file-watcher")
-        });
-        bootstrapLogger.info("Creating HTTP server");
-        const server = await createServer({
-          engine,
-          jobBroker,
-          workflowService,
-          cronScheduler,
-          cronDiscovery,
-          logger: createWorkflowLogger("api", "workflow.api")
-        });
-        await server.listen(getListenOptions(port, host));
-        bootstrapLogger.info("HTTP API listening", { port });
-        bootstrapLogger.info("Creating WorkflowWorker");
-        const worker = await createWorkflowWorker({
-          engine,
-          cliApi,
-          logger: createWorkflowLogger("worker", "workflow.worker"),
-          analytics: platform.analytics,
-          platform,
-          workspaceRoot: projectRoot,
-          concurrency: parseInt(process.env.WORKFLOW_CONCURRENCY ?? "5", 10),
-          debugMode
-        });
-        bootstrapLogger.info("Starting WorkflowWorker");
-        worker.start().catch((error) => {
-          bootstrapLogger.error(
-            "Worker crashed - shutting down daemon",
-            error instanceof Error ? error : void 0
-          );
-          process.kill(process.pid, "SIGTERM");
-        });
-        bootstrapLogger.info("Starting CronScheduler");
-        await cronScheduler.start();
-        bootstrapLogger.info("Workflow daemon started successfully", { port });
-        return async () => {
-          bootstrapLogger.warn("Stopping workflow daemon components");
-          fileWatcher.close();
-          await cronScheduler.stop();
-          await worker.stop();
-          await server.close();
-          await cliApi.dispose();
-        };
       }
-    },
-    (appId, repoRoot) => createServiceBootstrap({ appId, repoRoot, assemblyHook: makeAssemblyHook() })
-  );
+      const createWorkflowLogger = (service, operation, bindings) => serviceLogger.forComponent(`workflow-${service}`).forOperation(operation).with({});
+      bootstrapLogger.info("Loading plugin registry snapshot");
+      const cliApi = await createRegistry({
+        root: workspaceRoot,
+        platformRoot,
+        cache: { ttlMs: 10 * 60 * 1e3 }
+      });
+      await cliApi.initialize();
+      const plugins = await cliApi.listPlugins();
+      bootstrapLogger.info("Plugin registry snapshot loaded", {
+        pluginsFound: plugins.length,
+        pluginIds: plugins.map((p) => `${p.id}@${p.version}`)
+      });
+      bootstrapLogger.info("Creating WorkflowEngine");
+      const engine = new WorkflowEngine({
+        cache: platform.cache,
+        events: platform.eventBus,
+        logger: createWorkflowLogger("engine", "workflow.engine"),
+        snapshotManager: platform.snapshotManager,
+        workspaceRoot
+      });
+      bootstrapLogger.info(
+        "Cleaning up stale runs from previous daemon process"
+      );
+      await engine.cleanupStaleRuns();
+      bootstrapLogger.info("Resuming interrupted jobs");
+      await engine.resumeInterruptedJobs();
+      bootstrapLogger.info("Creating JobBroker");
+      const jobBroker = new JobBroker(
+        engine,
+        createWorkflowLogger("job-broker", "workflow.job-broker"),
+        platform
+      );
+      bootstrapLogger.info("Creating CronScheduler");
+      const cronScheduler = new CronScheduler({
+        jobBroker,
+        workflowEngine: engine,
+        logger: createWorkflowLogger(
+          "cron-scheduler",
+          "workflow.cron-scheduler"
+        ),
+        timezone: process.env.WORKFLOW_CRON_TIMEZONE
+      });
+      bootstrapLogger.info("Discovering cron jobs");
+      const cronDiscovery = new CronDiscovery({
+        cliApi,
+        scheduler: cronScheduler,
+        logger: createWorkflowLogger(
+          "cron-discovery",
+          "workflow.cron-discovery"
+        ),
+        workspaceRoot
+      });
+      const discovered = await cronDiscovery.discoverAll();
+      bootstrapLogger.info("Cron job discovery complete", discovered);
+      bootstrapLogger.info("Creating WorkflowService");
+      const workflowService = new WorkflowService({
+        cliApi,
+        platform,
+        workspaceRoot
+      });
+      workflowService.listAll().catch(
+        (err) => bootstrapLogger.warn("Manifest scanner warmup failed", { err })
+      );
+      bootstrapLogger.info("Starting WorkflowFileWatcher");
+      const fileWatcher = new WorkflowFileWatcher({
+        watchDirs: [
+          join(workspaceRoot, ".kb", "workflows"),
+          join(workspaceRoot, ".kb", "jobs")
+        ],
+        workflowService,
+        cronDiscovery,
+        cronScheduler,
+        logger: createWorkflowLogger("file-watcher", "workflow.file-watcher")
+      });
+      bootstrapLogger.info("Creating HTTP server");
+      const server = await createServer({
+        engine,
+        jobBroker,
+        workflowService,
+        cronScheduler,
+        cronDiscovery,
+        logger: createWorkflowLogger("api", "workflow.api")
+      });
+      await server.listen(getListenOptions(port, host));
+      bootstrapLogger.info("HTTP API listening", { port });
+      bootstrapLogger.info("Creating WorkflowWorker");
+      const worker = await createWorkflowWorker({
+        engine,
+        cliApi,
+        logger: createWorkflowLogger("worker", "workflow.worker"),
+        analytics: platform.analytics,
+        platform,
+        workspaceRoot,
+        concurrency: parseInt(process.env.WORKFLOW_CONCURRENCY ?? "5", 10),
+        debugMode
+      });
+      bootstrapLogger.info("Starting WorkflowWorker");
+      worker.start().catch((error) => {
+        bootstrapLogger.error(
+          "Worker crashed - shutting down daemon",
+          error instanceof Error ? error : void 0
+        );
+        process.kill(process.pid, "SIGTERM");
+      });
+      bootstrapLogger.info("Starting CronScheduler");
+      await cronScheduler.start();
+      bootstrapLogger.info("Workflow daemon started successfully", { port });
+      return async () => {
+        bootstrapLogger.warn("Stopping workflow daemon components");
+        fileWatcher.close();
+        await cronScheduler.stop();
+        await worker.stop();
+        await server.close();
+        await cliApi.dispose();
+      };
+    }
+  });
 }
 
 // src/index.ts
-(async () => {
-  try {
-    await bootstrap(process.cwd());
-  } catch (error) {
-    process.stderr.write(`[workflow-daemon] FATAL: ${error instanceof Error ? error.message : String(error)}
-`);
-    process.exit(1);
-  }
-})();
+bootstrap(process.cwd()).catch(() => {
+  process.exitCode = 1;
+});
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map