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

package/dist/src/pipelineCloseout.js

@@ -0,0 +1,465 @@
+// @bun
+// packages/bundle-default-lifecycle/src/pipelineCloseout.ts
+import { resolve } 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 { taskValidate } from "@rig/runtime/control-plane/native/task-ops";
+
+// 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";
+
+// packages/bundle-default-lifecycle/src/stages/types.ts
+function defineDefaultLifecycleStage(input) {
+  return {
+    ...input,
+    protected: input.protected ?? false,
+    priority: input.priority ?? 0
+  };
+}
+
+// packages/bundle-default-lifecycle/src/stages/auto-merge.ts
+var autoMergeStage = defineDefaultLifecycleStage({
+  id: "auto-merge",
+  kind: "transform",
+  description: "Merge an approved PR using the repository default merge method through the runtime helper.",
+  calls: ["runRepoDefaultMerge"]
+});
+async function runAutoMergeStage(input) {
+  await runRepoDefaultMerge(input);
+}
+
+// packages/bundle-default-lifecycle/src/stages/commit.ts
+import { commitRunChanges } from "@rig/runtime/control-plane/native/pr-automation";
+var commitStage = defineDefaultLifecycleStage({
+  id: "commit",
+  kind: "transform",
+  description: "Commit the agent worktree changes using the runtime git closeout helper.",
+  calls: ["commitRunChanges"]
+});
+async function runCommitStage(input) {
+  return await commitRunChanges(input);
+}
+
+// packages/bundle-default-lifecycle/src/stages/isolation.ts
+import { ensureAgentRuntime } from "@rig/runtime/control-plane/runtime/isolation";
+var isolationStage = defineDefaultLifecycleStage({
+  id: "isolation",
+  kind: "transform",
+  description: "Provision the isolated runtime worktree through the runtime isolation subsystem.",
+  calls: ["ensureAgentRuntime"],
+  protected: true
+});
+
+// packages/bundle-default-lifecycle/src/stages/journal-append.ts
+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
+});
+
+// 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
+});
+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";
+var openPrStage = defineDefaultLifecycleStage({
+  id: "open-pr",
+  kind: "transform",
+  description: "Open or reuse the closeout PR through the existing runtime PR automation seam.",
+  calls: ["runPrAutomation"]
+});
+async function runOpenPrStage(input) {
+  return await runPrAutomation({
+    projectRoot: input.workspace,
+    taskId: input.taskId,
+    runId: input.runId,
+    branch: input.branch,
+    sourceTask: input.sourceTask ? { title: typeof input.sourceTask.title === "string" ? input.sourceTask.title : null } : null,
+    command: input.command,
+    gitCommand: input.gitCommand,
+    steerPi: input.steerPi,
+    ...input.config ? { config: input.config } : {},
+    ...input.artifactRoot !== undefined ? { artifactRoot: input.artifactRoot } : {},
+    ...input.greptileApi !== undefined ? { greptileApi: input.greptileApi } : {},
+    ...input.lifecycle !== undefined ? { lifecycle: input.lifecycle } : {},
+    ...input.uploadedSnapshot !== undefined ? { uploadedSnapshot: input.uploadedSnapshot } : {}
+  });
+}
+
+// packages/bundle-default-lifecycle/src/stages/push.ts
+import { pushBranchSyncedWithOrigin } from "@rig/runtime/control-plane/native/pr-automation";
+var pushStage = defineDefaultLifecycleStage({
+  id: "push",
+  kind: "transform",
+  description: "Synchronize and push the task branch using the runtime closeout git helper.",
+  calls: ["pushBranchSyncedWithOrigin"]
+});
+async function runPushStage(input) {
+  await pushBranchSyncedWithOrigin(input);
+}
+
+// packages/bundle-default-lifecycle/src/stages/source-closeout.ts
+import { closeIssueAfterMergedPr } from "@rig/runtime/control-plane/native/pr-automation";
+var sourceCloseoutStage = defineDefaultLifecycleStage({
+  id: "source-closeout",
+  kind: "transform",
+  description: "Reflect the merged PR into the task source using the existing runtime closeout helper.",
+  calls: ["closeIssueAfterMergedPr"]
+});
+async function runSourceCloseoutStage(input) {
+  if (input.pr.status !== "merged" || !input.pr.prUrl)
+    return;
+  await closeIssueAfterMergedPr({
+    projectRoot: input.projectRoot,
+    taskId: input.taskId,
+    runId: input.runId,
+    prUrl: input.pr.prUrl,
+    updateTaskSource: input.updateTaskSource,
+    ...input.sourceTask !== undefined ? { sourceTask: input.sourceTask } : {}
+  });
+}
+
+// packages/bundle-default-lifecycle/src/stages/validate.ts
+var validateStage = defineDefaultLifecycleStage({
+  id: "validate",
+  kind: "transform",
+  description: "Run plugin-host validators against the isolated worktree before closeout side effects.",
+  calls: ["taskValidate"]
+});
+async function runValidateStage(input, runner) {
+  return await runner(input);
+}
+
+// packages/bundle-default-lifecycle/src/stages/verify.ts
+var verifyStage = defineDefaultLifecycleStage({
+  id: "verify",
+  kind: "gate",
+  description: "Run the local verifier preflight and block closeout when it rejects the worktree.",
+  calls: ["verifierPreflight"]
+});
+
+// packages/bundle-default-lifecycle/src/defaultPipeline.ts
+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,
+  commitStage,
+  pushStage,
+  openPrStage,
+  mergeGateStage,
+  autoMergeStage,
+  sourceCloseoutStage,
+  isolationStage,
+  journalAppendStage
+].map(withDefaultAnchors);
+function resolveDefaultLifecycle(input = {}) {
+  const grants = { protectedStageGrants: input.protectedStageGrants ?? [] };
+  return resolveKernelStages(defaultLifecycleStages, input.mutations ?? [], grants);
+}
+
+// packages/bundle-default-lifecycle/src/pipelineCloseout.ts
+function cleanString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function closeoutOutcome(status) {
+  switch (status) {
+    case "completed":
+      return "completed";
+    case "failed":
+    case "needs-attention":
+      return "failed";
+    case "pending":
+    case "running":
+      return "started";
+  }
+}
+async function loadRigAutomationConfig(projectRoot) {
+  try {
+    return await loadConfig(projectRoot);
+  } catch {
+    return null;
+  }
+}
+async function runRigProjectValidation({ projectRoot, taskId }) {
+  const pluginHostCtx = await buildPluginHostContext(projectRoot);
+  return taskValidate(projectRoot, taskId, pluginHostCtx?.validatorRegistry ?? undefined);
+}
+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("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 }
+  };
+  const openOnlyConfig = {
+    ...effectiveConfig,
+    merge: { ...effectiveConfig.merge ?? {}, mode: "pr-ready" }
+  };
+  const shouldMerge = shouldAttemptRigMerge(effectiveConfig);
+  const workspace = input.workspace;
+  const artifactRoot = input.artifactRoot ?? resolve(input.projectRoot, "artifacts", taskId);
+  const journal = async (phase, status, detail) => {
+    await input.journalPhase(phase, closeoutOutcome(status), detail ?? null);
+  };
+  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
+  };
+  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 });
+          }
+        }
+      });
+      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);
+      }
+      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: 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 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 };
+}
+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 {
+  runPipelineCloseout
+};

package/dist/src/plugin.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",
@@ -103,6 +107,21 @@ var verifyStage = defineDefaultLifecycleStage({
 });
 
 // packages/bundle-default-lifecycle/src/defaultPipeline.ts
+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,
@@ -114,7 +133,7 @@ var defaultLifecycleStages = [
   sourceCloseoutStage,
   isolationStage,
   journalAppendStage
-];
+].map(withDefaultAnchors);
 
 // packages/bundle-default-lifecycle/src/plugin.ts
 var DEFAULT_LIFECYCLE_PLUGIN_ID = "@rig/bundle-default-lifecycle";

package/dist/src/stages/merge-gate.d.ts

@@ -1 +1,24 @@
+import { type StrictPrGreptileApiOptions, type StrictPrMergeGateResult } from "@rig/runtime/control-plane/native/pr-review-gate";
+import type { GitHubCommandRunner } from "@rig/runtime/control-plane/native/pr-automation";
+export type MergeGateStageInput = {
+    readonly projectRoot: string;
+    readonly prUrl: string;
+    readonly taskId: string;
+    readonly runId: string;
+    readonly cycle: number;
+    readonly command: GitHubCommandRunner;
+    readonly artifactRoot?: string | null;
+    readonly allowedFailures?: readonly string[];
+    readonly greptileApi?: StrictPrGreptileApiOptions;
+    readonly final?: boolean;
+    readonly requireGreptile?: boolean;
+};
 export declare const mergeGateStage: import("./types").DefaultLifecycleStageDescriptor;
+/**
+ * Executable for the protected `merge-gate` stage. Wraps the runtime's strict
+ * merge gate (`runStrictPrMergeGate`) so the gate runs as a discrete resolved
+ * pipeline stage rather than only as logic embedded inside `runPrAutomation`.
+ * Returns the full {@link StrictPrMergeGateResult}; the caller maps it to a
+ * gate allow/block from `result.approved` / `result.pending`.
+ */
+export declare function runMergeGateStage(input: MergeGateStageInput): Promise<StrictPrMergeGateResult>;

package/dist/src/stages/merge-gate.js

@@ -1,4 +1,9 @@
 // @bun
+// packages/bundle-default-lifecycle/src/stages/merge-gate.ts
+import {
+  runStrictPrMergeGate
+} from "@rig/runtime/control-plane/native/pr-review-gate";
+
 // packages/bundle-default-lifecycle/src/stages/types.ts
 function defineDefaultLifecycleStage(input) {
   return {
@@ -16,6 +21,22 @@ 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 } : {}
+  });
+}
 export {
+  runMergeGateStage,
   mergeGateStage
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/bundle-default-lifecycle",
-  "version": "0.0.6-alpha.134",
+  "version": "0.0.6-alpha.136",
   "type": "module",
   "description": "Default Rig run lifecycle stage bundle wrapping the existing closeout runtime.",
   "license": "UNLICENSED",
@@ -25,9 +25,9 @@
       "types": "./dist/src/defaultPipeline.d.ts",
       "import": "./dist/src/defaultPipeline.js"
     },
-    "./staged-closeout": {
-      "types": "./dist/src/stagedCloseout.d.ts",
-      "import": "./dist/src/stagedCloseout.js"
+    "./pipeline-closeout": {
+      "types": "./dist/src/pipelineCloseout.d.ts",
+      "import": "./dist/src/pipelineCloseout.js"
     },
     "./plugin": {
       "types": "./dist/src/plugin.d.ts",
@@ -41,9 +41,9 @@
   "module": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "dependencies": {
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.134",
-    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.134",
-    "@rig/kernel": "npm:@h-rig/kernel@0.0.6-alpha.134",
-    "@rig/runtime": "npm:@h-rig/runtime@0.0.6-alpha.134"
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.136",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.136",
+    "@rig/kernel": "npm:@h-rig/kernel@0.0.6-alpha.136",
+    "@rig/runtime": "npm:@h-rig/runtime@0.0.6-alpha.136"
   }
 }

package/dist/src/stagedCloseout.d.ts

@@ -1,7 +0,0 @@
-import { type InProcessCloseoutInput, type InProcessCloseoutResult } from "@rig/runtime/control-plane/native/in-process-closeout";
-export type StagedCloseoutResult = {
-    readonly mode: "staged";
-    readonly pipelineStageIds: readonly string[];
-    readonly result: InProcessCloseoutResult;
-};
-export declare function runStagedCloseout(input: InProcessCloseoutInput): Promise<StagedCloseoutResult>;