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

package/dist/src/pipelineCloseout.d.ts

@@ -0,0 +1,14 @@
+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. The lifecycle plugin contributes stage descriptors as
+ * metadata and the per-run executor map as runtime; plugin contributions can
+ * mutate and execute alongside those defaults.
+ */
+export declare function runPipelineCloseout(input: InProcessCloseoutInput): Promise<PipelineCloseoutResult>;

package/dist/src/pipelineCloseout.js

@@ -0,0 +1,633 @@
+// @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,
+    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"]
+});
+
+// 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"]
+});
+
+// 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"]
+});
+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 = {}) {
+  return resolveKernelStages(defaultLifecycleStages, input.mutations ?? []);
+}
+function defaultPipelineShowData(input = {}) {
+  const resolved = resolveDefaultLifecycle(input);
+  const orderIndex = new Map(resolved.order.map((id, index) => [id, index + 1]));
+  const stages = resolved.record.map((entry) => ({
+    index: orderIndex.get(entry.stageId) ?? null,
+    id: entry.stageId,
+    contributedBy: entry.contributedBy,
+    ...entry.removedBy !== undefined ? { removedBy: entry.removedBy } : {},
+    ...entry.replacedBy !== undefined ? { replacedBy: entry.replacedBy } : {},
+    wrappedBy: entry.wrappedBy ?? [],
+    droppedAnchors: entry.droppedAnchors ?? []
+  }));
+  return {
+    title: `resolved run pipeline (${resolved.order.length} stages)`,
+    stageCount: resolved.order.length,
+    stages,
+    droppedAnchors: stages.flatMap((stage) => stage.droppedAnchors.map((anchor) => `${stage.id}:${anchor}`)),
+    cycles: resolved.cycles,
+    ...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}]`);
+      continue;
+    }
+    const ordinal = stage.index === null ? " -." : `${String(stage.index).padStart(2)}.`;
+    const annotations = [
+      stage.replacedBy ? `replaced by [${stage.replacedBy}]` : "",
+      stage.wrappedBy.length > 0 ? `wrapped by [${stage.wrappedBy.join(", ")}]` : ""
+    ].filter(Boolean);
+    lines.push(`  ${ordinal} ${stage.id.padEnd(20)} [${stage.contributedBy}]${annotations.length > 0 ? ` ${annotations.join("  ")}` : ""}`);
+  }
+  lines.push(`dropped anchors: ${data.droppedAnchors.length > 0 ? data.droppedAnchors.join(", ") : "none"}      cycles: ${data.cycles.length > 0 ? data.cycles.map((cycle) => cycle.join(" -> ")).join(", ") : "none"}`);
+  return lines.join(`
+`);
+}
+
+// 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;
+}
+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 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 {
+  runPipelineCloseout
+};

package/dist/src/plugin.d.ts

@@ -1,18 +1,19 @@
-import type { CapabilityTag } from "@rig/contracts";
+import { type RigPluginWithRuntime } from "@rig/core";
+import type { StageRun } from "@rig/contracts";
 import { defaultLifecycleStages } from "./defaultPipeline";
 export declare const DEFAULT_LIFECYCLE_PLUGIN_ID = "@rig/bundle-default-lifecycle";
-export type DefaultLifecyclePlugin = {
+export type DefaultLifecyclePlugin = RigPluginWithRuntime & {
     readonly meta: {
         readonly id: typeof DEFAULT_LIFECYCLE_PLUGIN_ID;
         readonly name: string;
         readonly version: string;
     };
-    readonly provides: ReadonlySet<CapabilityTag>;
-    readonly contributes: {
+    readonly contributes: NonNullable<RigPluginWithRuntime["contributes"]> & {
         readonly stages: typeof defaultLifecycleStages;
     };
     readonly runtime: {
-        readonly stages: typeof defaultLifecycleStages;
+        readonly stages: Readonly<Record<string, StageRun>>;
     };
 };
-export declare function createDefaultLifecyclePlugin(): DefaultLifecyclePlugin;
+export declare function createDefaultLifecyclePlugin(stages?: Readonly<Record<string, StageRun>>): DefaultLifecyclePlugin;
+export declare const defaultLifecyclePlugin: DefaultLifecyclePlugin;