@h-rig/bundle-default-lifecycle 0.0.6-alpha.135 → 0.0.6-alpha.136

package/dist/src/defaultPipeline.d.ts

@@ -3,7 +3,7 @@ import { type KernelStageResolverResult } from "@rig/kernel/resolver";
 import type { DefaultLifecycleStageDescriptor, DefaultLifecycleStageId } from "./stages/types";
 export declare const DEFAULT_LIFECYCLE_STAGE_IDS: readonly ["validate", "verify", "commit", "push", "open-pr", "merge-gate", "auto-merge", "source-closeout", "isolation", "journal-append"];
 export declare const PROTECTED_DEFAULT_LIFECYCLE_STAGE_IDS: readonly ["merge-gate", "isolation", "journal-append"];
-export declare const defaultLifecycleStages: readonly [DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor];
+export declare const defaultLifecycleStages: readonly DefaultLifecycleStageDescriptor[];
 export type ResolveDefaultLifecycleInput = {
     readonly mutations?: readonly StageMutation[];
     readonly protectedStageGrants?: readonly ProtectedStageGrant[];
@@ -29,4 +29,20 @@ export type PipelineShowData = {
     readonly resolvedAt?: string;
 };
 export declare function defaultPipelineShowData(input?: ResolveDefaultLifecycleInput): PipelineShowData;
+export type KernelStatusData = {
+    readonly kernelProviderId: string;
+    readonly kernelVersion: string;
+    readonly capabilities: Readonly<Record<string, string>>;
+    readonly protectedStages: readonly string[];
+    readonly pipelineStageCount: number;
+    readonly stageOrder: readonly string[];
+};
+/**
+ * Data backing `rig kernel status`: the resolved provider per kernel capability,
+ * the kernel version, the protected-stage set, and the resolved default
+ * pipeline. Derived from the default kernel plugin so it reflects what actually
+ * boots, not a hardcoded list.
+ */
+export declare function defaultKernelStatusData(): KernelStatusData;
+export declare function formatKernelStatus(data?: KernelStatusData): string;
 export declare function formatDefaultPipelineShow(input?: ResolveDefaultLifecycleInput): string;

package/dist/src/defaultPipeline.js

@@ -1,6 +1,7 @@
 // @bun
 // packages/bundle-default-lifecycle/src/defaultPipeline.ts
 import { resolveKernelStages } from "@rig/kernel/resolver";
+import { createDefaultKernelPlugin } from "@rig/kernel/default-kernel";
 
 // packages/bundle-default-lifecycle/src/stages/auto-merge.ts
 import { runRepoDefaultMerge } from "@rig/runtime/control-plane/native/pr-automation";
@@ -51,6 +52,9 @@ var journalAppendStage = defineDefaultLifecycleStage({
 });
 
 // packages/bundle-default-lifecycle/src/stages/merge-gate.ts
+import {
+  runStrictPrMergeGate
+} from "@rig/runtime/control-plane/native/pr-review-gate";
 var mergeGateStage = defineDefaultLifecycleStage({
   id: "merge-gate",
   kind: "gate",
@@ -116,6 +120,21 @@ var DEFAULT_LIFECYCLE_STAGE_IDS = [
   "journal-append"
 ];
 var PROTECTED_DEFAULT_LIFECYCLE_STAGE_IDS = ["merge-gate", "isolation", "journal-append"];
+var DEFAULT_STAGE_AFTER = {
+  verify: ["validate"],
+  commit: ["verify"],
+  push: ["commit"],
+  "open-pr": ["push"],
+  "merge-gate": ["open-pr"],
+  "auto-merge": ["merge-gate"],
+  "source-closeout": ["auto-merge"],
+  isolation: ["source-closeout"],
+  "journal-append": ["isolation"]
+};
+function withDefaultAnchors(stage) {
+  const after = DEFAULT_STAGE_AFTER[stage.id];
+  return after ? { ...stage, after } : stage;
+}
 var defaultLifecycleStages = [
   validateStage,
   verifyStage,
@@ -127,7 +146,7 @@ var defaultLifecycleStages = [
   sourceCloseoutStage,
   isolationStage,
   journalAppendStage
-];
+].map(withDefaultAnchors);
 function defaultLifecycleStageById(id) {
   const stage = defaultLifecycleStages.find((candidate) => candidate.id === id);
   if (!stage)
@@ -160,6 +179,32 @@ function defaultPipelineShowData(input = {}) {
     ...resolved.resolvedAt !== undefined ? { resolvedAt: resolved.resolvedAt } : {}
   };
 }
+function defaultKernelStatusData() {
+  const plugin = createDefaultKernelPlugin();
+  const resolved = resolveDefaultLifecycle();
+  const capabilities = {};
+  for (const capability of plugin.provides)
+    capabilities[capability] = plugin.meta.id;
+  return {
+    kernelProviderId: plugin.meta.id,
+    kernelVersion: plugin.meta.version,
+    capabilities,
+    protectedStages: [...PROTECTED_DEFAULT_LIFECYCLE_STAGE_IDS],
+    pipelineStageCount: resolved.order.length,
+    stageOrder: [...resolved.order]
+  };
+}
+function formatKernelStatus(data = defaultKernelStatusData()) {
+  const lines = [
+    `kernel: ${data.kernelProviderId} v${data.kernelVersion}`,
+    "capabilities (resolved provider):",
+    ...Object.entries(data.capabilities).map(([cap, provider]) => `  ${cap.padEnd(14)} ${provider}`),
+    `protected stages: ${data.protectedStages.join(", ")}`,
+    `resolved pipeline (${data.pipelineStageCount} stages): ${data.stageOrder.join(" -> ")}`
+  ];
+  return lines.join(`
+`);
+}
 function formatDefaultPipelineShow(input = {}) {
   const data = defaultPipelineShowData(input);
   const lines = [`${data.title}:`];
@@ -182,10 +227,12 @@ function formatDefaultPipelineShow(input = {}) {
 }
 export {
   resolveDefaultLifecycle,
+  formatKernelStatus,
   formatDefaultPipelineShow,
   defaultPipelineShowData,
   defaultLifecycleStages,
   defaultLifecycleStageById,
+  defaultKernelStatusData,
   PROTECTED_DEFAULT_LIFECYCLE_STAGE_IDS,
   DEFAULT_LIFECYCLE_STAGE_IDS
 };

package/dist/src/index.d.ts

@@ -1,7 +1,7 @@
 export * from "./closeoutEquivalence";
 export * from "./closeoutShadowHarness";
 export * from "./defaultPipeline";
-export * from "./stagedCloseout";
+export * from "./pipelineCloseout";
 export * from "./plugin";
 export * from "./stages/auto-merge";
 export * from "./stages/commit";

package/dist/src/index.js

@@ -96,6 +96,7 @@ function assertCloseoutShadowEquivalent(input) {
 }
 // packages/bundle-default-lifecycle/src/defaultPipeline.ts
 import { resolveKernelStages } from "@rig/kernel/resolver";
+import { createDefaultKernelPlugin } from "@rig/kernel/default-kernel";
 
 // packages/bundle-default-lifecycle/src/stages/auto-merge.ts
 import { runRepoDefaultMerge } from "@rig/runtime/control-plane/native/pr-automation";
@@ -158,6 +159,9 @@ async function runJournalAppendStage(input) {
 }
 
 // packages/bundle-default-lifecycle/src/stages/merge-gate.ts
+import {
+  runStrictPrMergeGate
+} from "@rig/runtime/control-plane/native/pr-review-gate";
 var mergeGateStage = defineDefaultLifecycleStage({
   id: "merge-gate",
   kind: "gate",
@@ -165,6 +169,21 @@ var mergeGateStage = defineDefaultLifecycleStage({
   calls: ["runStrictPrMergeGate"],
   protected: true
 });
+async function runMergeGateStage(input) {
+  return await runStrictPrMergeGate({
+    projectRoot: input.projectRoot,
+    prUrl: input.prUrl,
+    taskId: input.taskId,
+    runId: input.runId,
+    cycle: input.cycle,
+    command: input.command,
+    ...input.artifactRoot !== undefined ? { artifactRoot: input.artifactRoot } : {},
+    ...input.allowedFailures !== undefined ? { allowedFailures: input.allowedFailures } : {},
+    ...input.greptileApi !== undefined ? { greptileApi: input.greptileApi } : {},
+    ...input.final !== undefined ? { final: input.final } : {},
+    ...input.requireGreptile !== undefined ? { requireGreptile: input.requireGreptile } : {}
+  });
+}
 
 // packages/bundle-default-lifecycle/src/stages/open-pr.ts
 import { runPrAutomation } from "@rig/runtime/control-plane/native/pr-automation";
@@ -261,6 +280,21 @@ var DEFAULT_LIFECYCLE_STAGE_IDS = [
   "journal-append"
 ];
 var PROTECTED_DEFAULT_LIFECYCLE_STAGE_IDS = ["merge-gate", "isolation", "journal-append"];
+var DEFAULT_STAGE_AFTER = {
+  verify: ["validate"],
+  commit: ["verify"],
+  push: ["commit"],
+  "open-pr": ["push"],
+  "merge-gate": ["open-pr"],
+  "auto-merge": ["merge-gate"],
+  "source-closeout": ["auto-merge"],
+  isolation: ["source-closeout"],
+  "journal-append": ["isolation"]
+};
+function withDefaultAnchors(stage) {
+  const after = DEFAULT_STAGE_AFTER[stage.id];
+  return after ? { ...stage, after } : stage;
+}
 var defaultLifecycleStages = [
   validateStage,
   verifyStage,
@@ -272,7 +306,7 @@ var defaultLifecycleStages = [
   sourceCloseoutStage,
   isolationStage,
   journalAppendStage
-];
+].map(withDefaultAnchors);
 function defaultLifecycleStageById(id) {
   const stage = defaultLifecycleStages.find((candidate) => candidate.id === id);
   if (!stage)
@@ -305,6 +339,32 @@ function defaultPipelineShowData(input = {}) {
     ...resolved.resolvedAt !== undefined ? { resolvedAt: resolved.resolvedAt } : {}
   };
 }
+function defaultKernelStatusData() {
+  const plugin = createDefaultKernelPlugin();
+  const resolved = resolveDefaultLifecycle();
+  const capabilities = {};
+  for (const capability of plugin.provides)
+    capabilities[capability] = plugin.meta.id;
+  return {
+    kernelProviderId: plugin.meta.id,
+    kernelVersion: plugin.meta.version,
+    capabilities,
+    protectedStages: [...PROTECTED_DEFAULT_LIFECYCLE_STAGE_IDS],
+    pipelineStageCount: resolved.order.length,
+    stageOrder: [...resolved.order]
+  };
+}
+function formatKernelStatus(data = defaultKernelStatusData()) {
+  const lines = [
+    `kernel: ${data.kernelProviderId} v${data.kernelVersion}`,
+    "capabilities (resolved provider):",
+    ...Object.entries(data.capabilities).map(([cap, provider]) => `  ${cap.padEnd(14)} ${provider}`),
+    `protected stages: ${data.protectedStages.join(", ")}`,
+    `resolved pipeline (${data.pipelineStageCount} stages): ${data.stageOrder.join(" -> ")}`
+  ];
+  return lines.join(`
+`);
+}
 function formatDefaultPipelineShow(input = {}) {
   const data = defaultPipelineShowData(input);
   const lines = [`${data.title}:`];
@@ -325,11 +385,15 @@ function formatDefaultPipelineShow(input = {}) {
   return lines.join(`
 `);
 }
-// packages/bundle-default-lifecycle/src/stagedCloseout.ts
+// packages/bundle-default-lifecycle/src/pipelineCloseout.ts
 import { resolve as resolve2 } from "path";
 import { loadConfig } from "@rig/core/load-config";
+import { createPluginHost } from "@rig/core";
+import { createDefaultKernel } from "@rig/kernel/default-kernel";
 import { buildPluginHostContext } from "@rig/runtime/control-plane/plugin-host-context";
-import { CloseoutValidationError } from "@rig/runtime/control-plane/native/in-process-closeout";
+import {
+  CloseoutValidationError
+} from "@rig/runtime/control-plane/native/in-process-closeout";
 import { taskValidate } from "@rig/runtime/control-plane/native/task-ops";
 function cleanString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
@@ -346,9 +410,6 @@ function closeoutOutcome(status) {
       return "started";
   }
 }
-function normalizePrStatus(status) {
-  return status === "needs_attention" ? "needs-attention" : status;
-}
 async function loadRigAutomationConfig(projectRoot) {
   try {
     return await loadConfig(projectRoot);
@@ -360,130 +421,232 @@ async function runRigProjectValidation({ projectRoot, taskId }) {
   const pluginHostCtx = await buildPluginHostContext(projectRoot);
   return taskValidate(projectRoot, taskId, pluginHostCtx?.validatorRegistry ?? undefined);
 }
-async function executeStagedCloseout(input) {
+function shouldAttemptRigMerge(config) {
+  const mode = config.merge?.mode;
+  return mode !== "off" && mode !== "pr-ready";
+}
+async function loadPluginStageContributions(projectRoot) {
+  try {
+    const config = await loadConfig(projectRoot);
+    const host = createPluginHost(config.plugins ?? []);
+    return { executors: host.listStageExecutors(), mutations: host.listStageMutations() };
+  } catch {
+    return { executors: {}, mutations: [] };
+  }
+}
+async function runPipelineCloseout(input) {
   const taskId = cleanString(input.taskId);
   if (!taskId) {
-    throw new Error("Staged closeout requires a task id.");
+    throw new Error("Pipeline closeout requires a task id.");
   }
   const loadedConfig = input.config ?? await loadRigAutomationConfig(input.projectRoot);
   const prMode = loadedConfig?.pr?.mode ?? "off";
   const reviewProvider = loadedConfig?.review?.provider ?? "github";
   const effectiveConfig = {
     ...loadedConfig ?? {},
-    pr: {
-      ...loadedConfig?.pr ?? {},
-      mode: prMode
-    },
-    review: {
-      ...loadedConfig?.review ?? {},
-      provider: reviewProvider
-    }
+    pr: { ...loadedConfig?.pr ?? {}, mode: prMode },
+    review: { ...loadedConfig?.review ?? {}, provider: reviewProvider }
+  };
+  const openOnlyConfig = {
+    ...effectiveConfig,
+    merge: { ...effectiveConfig.merge ?? {}, mode: "pr-ready" }
   };
+  const shouldMerge = shouldAttemptRigMerge(effectiveConfig);
   const workspace = input.workspace;
   const artifactRoot = input.artifactRoot ?? resolve2(input.projectRoot, "artifacts", taskId);
-  let branch = input.branch;
-  let currentPhase = "queued";
   const journal = async (phase, status, detail) => {
-    currentPhase = phase;
     await input.journalPhase(phase, closeoutOutcome(status), detail ?? null);
   };
-  const complete = async (result, detail) => {
-    await journal("completed", "completed", detail);
-    return result;
+  if (prMode === "off" || prMode === "ask") {
+    const reason = prMode === "ask" ? "PR creation awaits operator approval." : "PR automation disabled.";
+    await input.reflect("under_review", reason);
+    await journal("completed", "completed", reason);
+    return {
+      mode: "pipeline",
+      pipelineStageIds: [...resolveDefaultLifecycle().order],
+      result: { status: "skipped", iterations: 0, feedback: [] }
+    };
+  }
+  const state = {
+    branch: input.branch,
+    validationPassed: false,
+    committed: false,
+    pushed: false,
+    prUrl: null,
+    prReady: false,
+    pr: null,
+    gate: null,
+    mergeGate: null,
+    merged: false,
+    iterations: 0,
+    feedback: [],
+    blockedDetail: null
   };
-  try {
-    if (prMode === "off" || prMode === "ask") {
-      const reason = prMode === "ask" ? "PR creation awaits operator approval." : "PR automation disabled.";
-      await input.reflect("under_review", reason);
-      return await complete({ status: "skipped", iterations: 0, feedback: [] }, reason);
-    }
-    await input.onValidationStart?.();
-    await journal("queued", "running", `Validating task ${taskId} before closeout.`);
-    let validationPassed = false;
-    try {
-      validationPassed = await runValidateStage({ projectRoot: input.projectRoot, taskId }, input.runValidation ?? runRigProjectValidation);
-    } catch (error) {
-      const detail2 = `Rig validation failed before closeout: ${error instanceof Error ? error.message : String(error)}`;
-      await input.reflect("needs_attention", "Rig validation failed before closeout; commit/push/PR automation is blocked.", { errorText: detail2 });
-      throw new CloseoutValidationError(detail2);
-    }
-    if (!validationPassed) {
-      const detail2 = `Rig validation failed for task ${taskId}; closeout blocked before commit.`;
-      await input.reflect("needs_attention", "Rig validation failed before closeout; commit/push/PR automation is blocked.", { errorText: detail2 });
-      throw new CloseoutValidationError(detail2);
-    }
-    await journal("queued", "completed", `Validation passed for task ${taskId}.`);
-    const workspaceBranch = await input.gitCommand(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: workspace });
-    const currentWorkspaceBranch = workspaceBranch.exitCode === 0 ? cleanString(workspaceBranch.stdout) : null;
-    if (currentWorkspaceBranch && currentWorkspaceBranch !== "HEAD" && currentWorkspaceBranch !== branch) {
-      branch = currentWorkspaceBranch;
-    }
-    await journal("commit", "running", `Committing changes in ${workspace}.`);
-    await runCommitStage({ cwd: workspace, message: `rig: complete task ${taskId}`, command: input.gitCommand });
-    await journal("push", "running", `Pushing branch ${branch}.`);
-    await runPushStage({ projectRoot: workspace, branch, gitCommand: input.gitCommand });
-    await journal("pr-review-merge", "running", `Opening and merging a pull request for ${branch}.`);
-    const pr = await runOpenPrStage({
-      ...input,
-      taskId,
-      branch,
-      artifactRoot,
-      config: effectiveConfig,
-      sourceTask: { title: cleanString(input.sourceTask?.title) },
-      lifecycle: {
-        onPrOpened: async ({ prUrl }) => {
-          await journal("pr-opened", "running", prUrl);
-          await input.reflect("under_review", "Rig opened a pull request for this task.");
-        },
-        onFeedback: async ({ feedback }) => {
-          await input.reflect("ci_fixing", "Rig is fixing CI/review feedback for this task.", { errorText: feedback.join(`
+  const cont = (ctx2) => ({ kind: "continue", ctx: ctx2 });
+  const executors = {
+    isolation: (ctx2) => cont(ctx2),
+    validate: async (ctx2) => {
+      await input.onValidationStart?.();
+      await journal("queued", "running", `Validating task ${taskId} before closeout.`);
+      let passed = false;
+      try {
+        passed = await runValidateStage({ projectRoot: input.projectRoot, taskId }, input.runValidation ?? runRigProjectValidation);
+      } catch (error) {
+        const detail = `Rig validation failed before closeout: ${error instanceof Error ? error.message : String(error)}`;
+        await input.reflect("needs_attention", "Rig validation failed before closeout; commit/push/PR automation is blocked.", { errorText: detail });
+        throw new CloseoutValidationError(detail);
+      }
+      if (!passed) {
+        const detail = `Rig validation failed for task ${taskId}; closeout blocked before commit.`;
+        await input.reflect("needs_attention", "Rig validation failed before closeout; commit/push/PR automation is blocked.", { errorText: detail });
+        throw new CloseoutValidationError(detail);
+      }
+      state.validationPassed = true;
+      await journal("queued", "completed", `Validation passed for task ${taskId}.`);
+      const workspaceBranch = await input.gitCommand(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: workspace });
+      const currentWorkspaceBranch = workspaceBranch.exitCode === 0 ? cleanString(workspaceBranch.stdout) : null;
+      if (currentWorkspaceBranch && currentWorkspaceBranch !== "HEAD" && currentWorkspaceBranch !== state.branch) {
+        state.branch = currentWorkspaceBranch;
+      }
+      return cont(ctx2);
+    },
+    verify: () => state.validationPassed ? { kind: "allow" } : { kind: "block", reason: "validation did not pass" },
+    commit: async (ctx2) => {
+      await journal("commit", "running", `Committing changes in ${workspace}.`);
+      const committed = await runCommitStage({ cwd: workspace, message: `rig: complete task ${taskId}`, command: input.gitCommand });
+      state.committed = committed.committed;
+      return cont(ctx2);
+    },
+    push: async (ctx2) => {
+      await journal("push", "running", `Pushing branch ${state.branch}.`);
+      await runPushStage({ projectRoot: workspace, branch: state.branch, gitCommand: input.gitCommand });
+      state.pushed = true;
+      return cont(ctx2);
+    },
+    "open-pr": async (ctx2) => {
+      await journal("pr-review-merge", "running", `Opening a pull request for ${state.branch}.`);
+      const pr = await runOpenPrStage({
+        ...input,
+        taskId,
+        branch: state.branch,
+        artifactRoot,
+        config: openOnlyConfig,
+        sourceTask: { title: cleanString(input.sourceTask?.title) },
+        lifecycle: {
+          onPrOpened: async ({ prUrl }) => {
+            await journal("pr-opened", "running", prUrl);
+            await input.reflect("under_review", "Rig opened a pull request for this task.");
+          },
+          onFeedback: async ({ feedback }) => {
+            await input.reflect("ci_fixing", "Rig is fixing CI/review feedback for this task.", { errorText: feedback.join(`
 `) || null });
-        },
-        onMergeStarted: async ({ prUrl }) => {
-          await journal("merge", "running", prUrl);
-          await input.reflect("merging", "Rig is merging the pull request for this task.");
-        },
-        onMerged: async ({ prUrl }) => {
-          await journal("close-source", "running", prUrl);
+          }
         }
+      });
+      state.pr = pr;
+      state.prUrl = pr.prUrl ?? null;
+      state.prReady = pr.status === "opened" || pr.status === "merged";
+      state.iterations = pr.iterations;
+      state.feedback = [...pr.actionableFeedback];
+      if (pr.status === "needs_attention") {
+        state.blockedDetail = pr.actionableFeedback.join(`
+`) || "PR automation did not produce a mergeable PR.";
+      }
+      return cont(ctx2);
+    },
+    "merge-gate": async (ctx2) => {
+      if (!shouldMerge || !state.prReady || !state.prUrl) {
+        state.mergeGate = state.prReady ? "skipped" : null;
+        return state.prReady ? cont(ctx2) : { kind: "block", reason: state.blockedDetail ?? "no mergeable PR to gate" };
+      }
+      const gate = await runMergeGateStage({
+        projectRoot: workspace,
+        prUrl: state.prUrl,
+        taskId,
+        runId: input.runId,
+        cycle: 1,
+        command: input.command,
+        artifactRoot,
+        final: true,
+        ...effectiveConfig.merge?.allowedFailures ? { allowedFailures: effectiveConfig.merge.allowedFailures } : {},
+        ...input.greptileApi !== undefined ? { greptileApi: input.greptileApi } : {},
+        requireGreptile: reviewProvider === "greptile"
+      });
+      state.gate = gate;
+      if (gate.approved) {
+        state.mergeGate = "passed";
+        return cont(ctx2);
+      }
+      state.mergeGate = "blocked";
+      const detail = gate.actionableFeedback.join(`
+`) || gate.reasons.join("; ") || "merge gate blocked the PR.";
+      state.blockedDetail = detail;
+      await input.reflect("needs_attention", "Rig needs operator attention before this task can merge.", { errorText: detail });
+      await journal("pr-review-merge", "needs-attention", detail);
+      return { kind: "block", reason: detail };
+    },
+    "auto-merge": async (ctx2) => {
+      if (!shouldMerge || state.mergeGate !== "passed" || !state.prUrl || !state.gate) {
+        return cont(ctx2);
       }
-    });
-    if (pr.status === "merged" && pr.prUrl) {
+      await journal("merge", "running", state.prUrl);
+      await input.reflect("merging", "Rig is merging the pull request for this task.");
+      await runAutoMergeStage({ prUrl: state.prUrl, config: effectiveConfig, command: input.command, cwd: workspace, strictGate: state.gate });
+      state.merged = true;
+      return cont(ctx2);
+    },
+    "source-closeout": async (ctx2) => {
+      if (!state.merged || !state.prUrl)
+        return cont(ctx2);
+      await journal("close-source", "running", state.prUrl);
+      const mergedPr = { ...state.pr ?? { iterations: state.iterations, actionableFeedback: state.feedback }, status: "merged", prUrl: state.prUrl, merged: true };
       await runSourceCloseoutStage({
         projectRoot: input.projectRoot,
         taskId,
         runId: input.runId,
-        pr,
+        pr: mergedPr,
         ...input.sourceTask !== undefined ? { sourceTask: input.sourceTask } : {},
         updateTaskSource: async () => {
           await input.reflect("closed", "Rig merged the pull request and closed this task source.");
           return { updated: true, taskId, status: "closed", source: "runtime", sourceKind: "runtime" };
         }
       });
-      return await complete({ status: "merged", prUrl: pr.prUrl, iterations: pr.iterations, feedback: pr.actionableFeedback }, `PR merged and issue closed: ${pr.prUrl}`);
-    }
-    if (pr.status === "opened" && pr.prUrl) {
-      return await complete({ status: "opened", prUrl: pr.prUrl, iterations: pr.iterations, feedback: pr.actionableFeedback }, `PR ready without merge: ${pr.prUrl}`);
-    }
-    const detail = pr.actionableFeedback.join(`
-`) || "PR automation did not merge the PR.";
-    await input.reflect("needs_attention", "Rig needs operator attention before this task can proceed.", { errorText: detail });
-    await journal("pr-review-merge", "needs-attention", detail);
-    return { status: normalizePrStatus(pr.status), ...pr.prUrl ? { prUrl: pr.prUrl } : {}, iterations: pr.iterations, feedback: pr.actionableFeedback };
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    await journal(currentPhase, "failed", detail);
-    throw error;
+      return cont(ctx2);
+    },
+    "journal-append": (ctx2) => cont(ctx2)
+  };
+  const pluginStages = await loadPluginStageContributions(input.projectRoot);
+  const kernel = createDefaultKernel({ stageExecutors: { ...executors, ...pluginStages.executors } });
+  const resolved = kernel.stageRunner.resolve(defaultLifecycleStages, pluginStages.mutations);
+  const ctx = {
+    runId: input.runId,
+    taskId,
+    state,
+    metadata: { projectRoot: input.projectRoot, workspace }
+  };
+  await kernel.stageRunner.runPipeline(input.runId, resolved, ctx);
+  const result = mapStateToResult(state);
+  if (result.status === "merged" || result.status === "opened") {
+    await journal("completed", "completed", result.prUrl ? `${result.status === "merged" ? "PR merged and issue closed" : "PR ready without merge"}: ${result.prUrl}` : result.status);
   }
+  return { mode: "pipeline", pipelineStageIds: [...resolved.order], result };
 }
-async function runStagedCloseout(input) {
-  const resolved = resolveDefaultLifecycle();
-  const result = await executeStagedCloseout(input);
-  return {
-    mode: "staged",
-    pipelineStageIds: [...resolved.order],
-    result
-  };
+function mapStateToResult(state) {
+  if (state.merged && state.prUrl) {
+    return { status: "merged", prUrl: state.prUrl, iterations: state.iterations, feedback: state.feedback };
+  }
+  if (state.mergeGate === "blocked" || state.blockedDetail) {
+    return {
+      status: "needs-attention",
+      ...state.prUrl ? { prUrl: state.prUrl } : {},
+      iterations: state.iterations,
+      feedback: state.feedback
+    };
+  }
+  if (state.prReady && state.prUrl) {
+    return { status: "opened", prUrl: state.prUrl, iterations: state.iterations, feedback: state.feedback };
+  }
+  return { status: "needs-attention", ...state.prUrl ? { prUrl: state.prUrl } : {}, iterations: state.iterations, feedback: state.feedback };
 }
 // packages/bundle-default-lifecycle/src/plugin.ts
 var DEFAULT_LIFECYCLE_PLUGIN_ID = "@rig/bundle-default-lifecycle";
@@ -502,10 +665,11 @@ export {
   snapshotCloseoutArtifacts,
   runVerifyStage,
   runValidateStage,
-  runStagedCloseout,
   runSourceCloseoutStage,
   runPushStage,
+  runPipelineCloseout,
   runOpenPrStage,
+  runMergeGateStage,
   runJournalAppendStage,
   runIsolationStage,
   runCommitStage,
@@ -516,11 +680,13 @@ export {
   mergeGateStage,
   journalAppendStage,
   isolationStage,
+  formatKernelStatus,
   formatDefaultPipelineShow,
   defineDefaultLifecycleStage,
   defaultPipelineShowData,
   defaultLifecycleStages,
   defaultLifecycleStageById,
+  defaultKernelStatusData,
   createDefaultLifecyclePlugin,
   compareCloseoutShadowRuns,
   compareCloseoutEquivalence,

package/dist/src/pipelineCloseout.d.ts

@@ -0,0 +1,17 @@
+import { type InProcessCloseoutInput, type InProcessCloseoutResult } from "@rig/runtime/control-plane/native/in-process-closeout";
+export type PipelineCloseoutResult = {
+    readonly mode: "pipeline";
+    /** The resolved stage order the kernel executed (the journal-recorded pipeline). */
+    readonly pipelineStageIds: readonly string[];
+    readonly result: InProcessCloseoutResult;
+};
+/**
+ * Run the default-lifecycle closeout as a resolved stage pipeline driven by the
+ * kernel's stage runner. Each kernel stage executor invokes the corresponding
+ * `run<Stage>` wrapper against the shared closeout state, so `open-pr`,
+ * `merge-gate`, and `auto-merge` are discrete executed stages (the protected
+ * `merge-gate` runs `runStrictPrMergeGate` as a real gate, blocking the
+ * pipeline when the PR is not approved). This is the single closeout path; the
+ * earlier parallel imperative `runStagedCloseout` copy is retired.
+ */
+export declare function runPipelineCloseout(input: InProcessCloseoutInput): Promise<PipelineCloseoutResult>;