@kb-labs/workflow-daemon 2.116.14 → 2.117.0

package/dist/index.js

@@ -19,6 +19,7 @@ import { randomUUID } from 'crypto';
 async function createWorkflowWorker(options) {
   const {
     engine,
+    workflowService,
     cliApi,
     logger,
     platform,
@@ -46,6 +47,58 @@ async function createWorkflowWorker(options) {
     workspaceRoot,
     defaultTimeout
   });
+  async function invokeChildWorkflow(input) {
+    if (!workflowService) {
+      throw new Error("Workflow invocation is unavailable: WorkflowService was not configured");
+    }
+    if (!input.workflowRef.startsWith("workspace:")) {
+      throw new Error(`Unsupported child workflow reference: workflow:${input.workflowRef}`);
+    }
+    const workflowId = input.workflowRef.slice("workspace:".length);
+    const parentWorkflowId = input.parentRun.metadata?.["workflowId"] ?? input.parentRun.name;
+    const ancestors = input.parentRun.metadata?.workflowAncestors ?? [parentWorkflowId];
+    if (ancestors.includes(workflowId)) {
+      throw new Error(`Child workflow cycle detected: ${[...ancestors, workflowId].join(" -> ")}`);
+    }
+    const parentDepth = input.parentRun.metadata?.workflowDepth ?? 0;
+    if (parentDepth >= engine.maxWorkflowDepth) {
+      throw new Error(`Child workflow depth exceeds maxWorkflowDepth=${engine.maxWorkflowDepth}`);
+    }
+    const workflow = await workflowService.get(workflowId);
+    const spec = workflow?.input;
+    if (!workflow || !spec?.jobs) {
+      throw new Error(`Child workflow not found or is not executable: ${workflowId}`);
+    }
+    const child = await engine.runFromSpec(spec, {
+      trigger: {
+        type: "workflow",
+        actor: input.parentRun.trigger.actor,
+        payload: input.inputs,
+        parentRunId: input.parentRun.id,
+        parentJobId: input.parentJob.id,
+        parentStepId: input.parentStep.id,
+        invokedByWorkflowId: parentWorkflowId
+      },
+      inputs: input.inputs,
+      env: input.parentRun.env,
+      metadata: {
+        workflowId,
+        parentRunId: input.parentRun.id,
+        parentJobId: input.parentJob.id,
+        parentStepId: input.parentStep.id,
+        workflowDepth: parentDepth + 1,
+        rootRunId: input.parentRun.metadata?.rootRunId ?? input.parentRun.id,
+        workflowAncestors: [...ancestors, workflowId],
+        // A composed quality workflow must inspect and repair the exact change
+        // prepared by its parent, not a fresh worktree at main. The owner keeps
+        // lifecycle responsibility; children only borrow this binding.
+        executionWorkspace: input.parentRun.metadata?.["executionWorkspace"],
+        workspaceOwnerRunId: input.parentRun.metadata?.["workspaceOwnerRunId"] ?? input.parentRun.id
+      }
+    });
+    await engine.markStepWaitingChild(input.parentRun.id, input.parentJob.id, input.parentStep.id, child.id);
+    await engine.reconcileChildInvocation(child.id);
+  }
   async function processJob() {
     const entry = await engine.nextJob();
     if (!entry) {
@@ -118,7 +171,17 @@ async function createWorkflowWorker(options) {
     const wsProvider2 = platform.getAdapter("workspace");
     let runWorkspace = wsProvider2 ? workspaceRoot : process.env["KB_PROJECT_ROOT"] ?? workspaceRoot;
     let provisionedWorkspaceId;
-    if (wsProvider2) {
+    const workspaceMetadata = run.metadata?.["executionWorkspace"];
+    const inheritedWorkspace = typeof run.metadata?.["workspaceOwnerRunId"] === "string" && run.metadata?.["workspaceOwnerRunId"] !== run.id;
+    if (workspaceMetadata && typeof workspaceMetadata.rootPath === "string" && typeof workspaceMetadata.workspaceId === "string") {
+      runWorkspace = workspaceMetadata.rootPath;
+      provisionedWorkspaceId = inheritedWorkspace ? void 0 : workspaceMetadata.workspaceId;
+      jobLogger.info("Workspace binding restored", {
+        workspaceId: workspaceMetadata.workspaceId,
+        ownerRunId: run.metadata?.["workspaceOwnerRunId"] ?? run.id,
+        inherited: inheritedWorkspace
+      });
+    } else if (wsProvider2) {
       const wsId = `wt_${run.id.slice(0, 8)}`;
       try {
         const ws = await wsProvider2.materialize({
@@ -133,8 +196,16 @@ async function createWorkflowWorker(options) {
           }
         });
         if (ws.rootPath) {
-          runWorkspace = ws.rootPath;
+          const rootPath = ws.rootPath;
+          runWorkspace = rootPath;
           provisionedWorkspaceId = ws.workspaceId;
+          await engine.getStateStore().updateRun(run.id, (draft) => {
+            draft.metadata = {
+              ...draft.metadata ?? {},
+              executionWorkspace: { workspaceId: ws.workspaceId, rootPath },
+              workspaceOwnerRunId: run.id
+            };
+          });
           jobLogger.info("Workspace provisioned", {
             workspaceId: ws.workspaceId,
             provider: ws.provider,
@@ -174,6 +245,9 @@ async function createWorkflowWorker(options) {
           if (step.status === "success") {
             continue;
           }
+          if (step.status === "waiting_child") {
+            return;
+          }
           const freshRun = await engine.getRun(run.id);
           if (freshRun?.status === "cancelled") {
             jobLogger.info("[worker] Run cancelled \u2014 stopping step execution", {
@@ -332,6 +406,16 @@ async function createWorkflowWorker(options) {
             }
             continue;
           }
+          if (step.spec.uses?.startsWith("workflow:")) {
+            await invokeChildWorkflow({
+              parentRun: run,
+              parentJob: job,
+              parentStep: step,
+              workflowRef: step.spec.uses.slice("workflow:".length),
+              inputs: interpolatedWith ?? {}
+            });
+            return;
+          }
           if (step.spec.uses === "builtin:gate") {
             const gateInput = interpolatedWith ?? {};
             const currentIteration = step.metadata?.["iterations"] ?? 0;
@@ -1957,7 +2041,11 @@ var WorkflowHostService = class {
         actor: request.trigger?.user,
         payload: userInputs
       },
-      inputs: resolvedInputs
+      inputs: resolvedInputs,
+      metadata: {
+        workflowId: id,
+        workflowAncestors: [id]
+      }
     });
     return {
       runId: run.id,
@@ -1990,7 +2078,11 @@ var WorkflowHostService = class {
         actor: "cli-rerun",
         payload: resolvedInputs
       },
-      inputs: resolvedInputs
+      inputs: resolvedInputs,
+      metadata: {
+        workflowId,
+        workflowAncestors: [workflowId]
+      }
     });
     return {
       runId: run.id,
@@ -3249,6 +3341,11 @@ async function bootstrap(_cwd = process.cwd()) {
       await engine.cleanupStaleRuns();
       bootstrapLogger.info("Resuming interrupted jobs");
       await engine.resumeInterruptedJobs();
+      bootstrapLogger.info("Reconciling persisted child workflow invocations");
+      const reconciledChildren = await engine.reconcileChildInvocations();
+      if (reconciledChildren > 0) {
+        bootstrapLogger.info("Reconciled child workflow invocations", { count: reconciledChildren });
+      }
       bootstrapLogger.info("Creating JobBroker");
       const jobBroker = new JobBroker(
         engine,
@@ -3311,6 +3408,7 @@ async function bootstrap(_cwd = process.cwd()) {
       bootstrapLogger.info("Creating WorkflowWorker");
       const worker = await createWorkflowWorker({
         engine,
+        workflowService,
         cliApi,
         logger: createWorkflowLogger("worker", "workflow.worker"),
         analytics: platform.analytics,