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

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";
@@ -104,7 +105,6 @@ import { runRepoDefaultMerge } from "@rig/runtime/control-plane/native/pr-automa
 function defineDefaultLifecycleStage(input) {
   return {
     ...input,
-    protected: input.protected ?? false,
     priority: input.priority ?? 0
   };
 }
@@ -138,8 +138,7 @@ var isolationStage = defineDefaultLifecycleStage({
   id: "isolation",
   kind: "transform",
   description: "Provision the isolated runtime worktree through the runtime isolation subsystem.",
-  calls: ["ensureAgentRuntime"],
-  protected: true
+  calls: ["ensureAgentRuntime"]
 });
 async function runIsolationStage(input) {
   return await ensureAgentRuntime(input);
@@ -150,21 +149,37 @@ var journalAppendStage = defineDefaultLifecycleStage({
   id: "journal-append",
   kind: "observe",
   description: "Record resolved pipeline and per-stage outcome entries through the kernel journal capability.",
-  calls: ["journalCapability.append"],
-  protected: true
+  calls: ["journalCapability.append"]
 });
 async function runJournalAppendStage(input) {
   await input.journal.append(input.event);
 }
 
 // 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",
   description: "Enforce GitHub review state, required checks, and configured review gates through runtime PR automation.",
-  calls: ["runStrictPrMergeGate"],
-  protected: true
+  calls: ["runStrictPrMergeGate"]
 });
+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";
@@ -260,7 +275,21 @@ var DEFAULT_LIFECYCLE_STAGE_IDS = [
   "isolation",
   "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 +301,7 @@ var defaultLifecycleStages = [
   sourceCloseoutStage,
   isolationStage,
   journalAppendStage
-];
+].map(withDefaultAnchors);
 function defaultLifecycleStageById(id) {
   const stage = defaultLifecycleStages.find((candidate) => candidate.id === id);
   if (!stage)
@@ -280,8 +309,7 @@ function defaultLifecycleStageById(id) {
   return stage;
 }
 function resolveDefaultLifecycle(input = {}) {
-  const grants = { protectedStageGrants: input.protectedStageGrants ?? [] };
-  return resolveKernelStages(defaultLifecycleStages, input.mutations ?? [], grants);
+  return resolveKernelStages(defaultLifecycleStages, input.mutations ?? []);
 }
 function defaultPipelineShowData(input = {}) {
   const resolved = resolveDefaultLifecycle(input);
@@ -290,7 +318,6 @@ function defaultPipelineShowData(input = {}) {
     index: orderIndex.get(entry.stageId) ?? null,
     id: entry.stageId,
     contributedBy: entry.contributedBy,
-    protected: entry.isProtected,
     ...entry.removedBy !== undefined ? { removedBy: entry.removedBy } : {},
     ...entry.replacedBy !== undefined ? { replacedBy: entry.replacedBy } : {},
     wrappedBy: entry.wrappedBy ?? [],
@@ -305,17 +332,41 @@ 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,
+    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}`),
+    `lifecycle stages: mutable`,
+    `resolved pipeline (${data.pipelineStageCount} stages): ${data.stageOrder.join(" -> ")}`
+  ];
+  return lines.join(`
+`);
+}
 function formatDefaultPipelineShow(input = {}) {
   const data = defaultPipelineShowData(input);
   const lines = [`${data.title}:`];
   for (const stage of data.stages) {
     if (stage.removedBy) {
-      lines.push(`  - ${stage.id.padEnd(20)} [${stage.contributedBy}] removed by [${stage.removedBy}]${stage.protected ? " PROTECTED" : ""}`);
+      lines.push(`  - ${stage.id.padEnd(20)} [${stage.contributedBy}] removed by [${stage.removedBy}]`);
       continue;
     }
     const ordinal = stage.index === null ? " -." : `${String(stage.index).padStart(2)}.`;
     const annotations = [
-      stage.protected ? "PROTECTED" : "",
       stage.replacedBy ? `replaced by [${stage.replacedBy}]` : "",
       stage.wrappedBy.length > 0 ? `wrapped by [${stage.wrappedBy.join(", ")}]` : ""
     ].filter(Boolean);
@@ -325,12 +376,125 @@ 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";
+
+// packages/bundle-default-lifecycle/src/plugin.ts
+import { definePlugin } from "@rig/core";
+
+// packages/bundle-default-lifecycle/src/cli.ts
+var DEFAULT_PIPELINE_CLI_ID = "default-lifecycle.pipeline";
+var DEFAULT_KERNEL_CLI_ID = "default-lifecycle.kernel";
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function takeFlag(args, flag) {
+  const rest = [...args];
+  const index = rest.indexOf(flag);
+  if (index < 0)
+    return { value: false, rest };
+  rest.splice(index, 1);
+  return { value: true, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0)
+    throw new Error(`Unexpected argument: ${args[0]}
+Usage: ${usage}`);
+}
+async function executePipeline(context, args) {
+  const [first = "show", ...rest] = args;
+  const command = first.startsWith("-") ? "show" : first;
+  const commandArgs = first.startsWith("-") ? args : rest;
+  if (command !== "show")
+    throw new Error(`Unknown pipeline command: ${command}`);
+  const json = takeFlag(commandArgs, "--json");
+  requireNoExtraArgs(json.rest, "rig pipeline show [--json]");
+  const details = defaultPipelineShowData();
+  if (context.outputMode === "text") {
+    if (json.value)
+      printJson(details);
+    else
+      console.log(formatDefaultPipelineShow());
+  }
+  return { ok: true, group: "pipeline", command: "show", details };
+}
+async function executeKernel(context, args) {
+  const [first = "status", ...rest] = args;
+  const command = first.startsWith("-") ? "status" : first;
+  const commandArgs = first.startsWith("-") ? args : rest;
+  if (command !== "status")
+    throw new Error(`Unknown kernel command: ${command}`);
+  const json = takeFlag(commandArgs, "--json");
+  requireNoExtraArgs(json.rest, "rig kernel status [--json]");
+  const details = defaultKernelStatusData();
+  if (context.outputMode === "text") {
+    if (json.value)
+      printJson(details);
+    else
+      console.log(formatKernelStatus(details));
+  }
+  return { ok: true, group: "kernel", command: "status", details };
+}
+var defaultLifecycleCliCommands = [
+  {
+    id: DEFAULT_PIPELINE_CLI_ID,
+    family: "pipeline",
+    command: "rig pipeline show [--json]",
+    description: "Show the resolved default lifecycle pipeline.",
+    usage: "rig pipeline show [--json]",
+    run: executePipeline
+  },
+  {
+    id: DEFAULT_KERNEL_CLI_ID,
+    family: "kernel",
+    command: "rig kernel status [--json]",
+    description: "Show default kernel provider and lifecycle status.",
+    usage: "rig kernel status [--json]",
+    run: executeKernel
+  }
+];
+
+// packages/bundle-default-lifecycle/src/plugin.ts
+var DEFAULT_LIFECYCLE_PLUGIN_ID = "@rig/bundle-default-lifecycle";
+function createDefaultLifecyclePlugin(stages = {}) {
+  const plugin = definePlugin({
+    name: DEFAULT_LIFECYCLE_PLUGIN_ID,
+    version: "0.0.0-alpha.1",
+    provides: [],
+    contributes: {
+      stages: defaultLifecycleStages,
+      capabilities: [
+        { id: "default-lifecycle.pipeline", title: "Default lifecycle pipeline", commandId: DEFAULT_PIPELINE_CLI_ID },
+        { id: "default-lifecycle.kernel-status", title: "Default kernel status", commandId: DEFAULT_KERNEL_CLI_ID }
+      ],
+      cliCommands: defaultLifecycleCliCommands.map(({ run: _run, ...metadata }) => metadata)
+    }
+  }, {
+    stages,
+    featureCapabilities: [
+      { id: "default-lifecycle.pipeline", title: "Default lifecycle pipeline", commandId: DEFAULT_PIPELINE_CLI_ID },
+      { id: "default-lifecycle.kernel-status", title: "Default kernel status", commandId: DEFAULT_KERNEL_CLI_ID }
+    ],
+    cliCommands: defaultLifecycleCliCommands
+  });
+  return {
+    ...plugin,
+    meta: { id: DEFAULT_LIFECYCLE_PLUGIN_ID, name: "Default Rig Lifecycle", version: "0.0.0-alpha.1" },
+    contributes: { ...plugin.contributes ?? {}, stages: defaultLifecycleStages },
+    runtime: { stages }
+  };
+}
+var defaultLifecyclePlugin = createDefaultLifecyclePlugin();
+
+// packages/bundle-default-lifecycle/src/pipelineCloseout.ts
 function cleanString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -346,9 +510,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,140 +521,233 @@ 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;
-  }
-}
-async function runStagedCloseout(input) {
-  const resolved = resolveDefaultLifecycle();
-  const result = await executeStagedCloseout(input);
-  return {
-    mode: "staged",
-    pipelineStageIds: [...resolved.order],
-    result
+      return cont(ctx2);
+    },
+    "journal-append": (ctx2) => cont(ctx2)
   };
-}
-// packages/bundle-default-lifecycle/src/plugin.ts
-var DEFAULT_LIFECYCLE_PLUGIN_ID = "@rig/bundle-default-lifecycle";
-function createDefaultLifecyclePlugin() {
-  return {
-    meta: { id: DEFAULT_LIFECYCLE_PLUGIN_ID, name: "Default Rig Lifecycle", version: "0.0.0-alpha.1" },
-    provides: new Set,
-    contributes: { stages: defaultLifecycleStages },
-    runtime: { stages: defaultLifecycleStages }
+  const defaultLifecyclePlugin2 = createDefaultLifecyclePlugin(executors);
+  const pluginStages = await loadPluginStageContributions(input.projectRoot);
+  const kernel = createDefaultKernel({ ...input.kernelJournal ? { journal: input.kernelJournal } : {}, stageExecutors: { ...defaultLifecyclePlugin2.runtime.stages, ...pluginStages.executors } });
+  const resolved = kernel.stageRunner.resolve(defaultLifecyclePlugin2.contributes.stages, pluginStages.mutations);
+  const ctx = {
+    runId: input.runId,
+    taskId,
+    state,
+    metadata: { projectRoot: input.projectRoot, workspace, closeoutState: state }
   };
+  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 };
+}
+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 };
 }
 export {
   verifyStage,
@@ -502,10 +756,11 @@ export {
   snapshotCloseoutArtifacts,
   runVerifyStage,
   runValidateStage,
-  runStagedCloseout,
   runSourceCloseoutStage,
   runPushStage,
+  runPipelineCloseout,
   runOpenPrStage,
+  runMergeGateStage,
   runJournalAppendStage,
   runIsolationStage,
   runCommitStage,
@@ -516,20 +771,27 @@ export {
   mergeGateStage,
   journalAppendStage,
   isolationStage,
+  formatKernelStatus,
   formatDefaultPipelineShow,
+  executePipeline,
+  executeKernel,
   defineDefaultLifecycleStage,
   defaultPipelineShowData,
   defaultLifecycleStages,
   defaultLifecycleStageById,
+  defaultLifecyclePlugin,
+  defaultLifecycleCliCommands,
+  defaultKernelStatusData,
   createDefaultLifecyclePlugin,
   compareCloseoutShadowRuns,
   compareCloseoutEquivalence,
   commitStage,
   autoMergeStage,
   assertCloseoutShadowEquivalent,
-  PROTECTED_DEFAULT_LIFECYCLE_STAGE_IDS,
+  DEFAULT_PIPELINE_CLI_ID,
   DEFAULT_LIFECYCLE_STAGE_IDS,
   DEFAULT_LIFECYCLE_PLUGIN_ID,
+  DEFAULT_KERNEL_CLI_ID,
   CLOSEOUT_EQUIVALENCE_STATE_FILES,
   CLOSEOUT_EQUIVALENCE_ARTIFACTS
 };