@h-rig/bundle-default-lifecycle 0.0.6-alpha.133

package/dist/src/stagedCloseout.js

@@ -0,0 +1,325 @@
+// @bun
+// packages/bundle-default-lifecycle/src/stagedCloseout.ts
+import { resolve } from "path";
+import { loadConfig } from "@rig/core/load-config";
+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";
+
+// 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"]
+});
+
+// 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
+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
+});
+
+// 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 defaultLifecycleStages = [
+  validateStage,
+  verifyStage,
+  commitStage,
+  pushStage,
+  openPrStage,
+  mergeGateStage,
+  autoMergeStage,
+  sourceCloseoutStage,
+  isolationStage,
+  journalAppendStage
+];
+function resolveDefaultLifecycle(input = {}) {
+  const grants = { protectedStageGrants: input.protectedStageGrants ?? [] };
+  return resolveKernelStages(defaultLifecycleStages, input.mutations ?? [], grants);
+}
+
+// packages/bundle-default-lifecycle/src/stagedCloseout.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";
+  }
+}
+function normalizePrStatus(status) {
+  return status === "needs_attention" ? "needs-attention" : status;
+}
+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);
+}
+async function executeStagedCloseout(input) {
+  const taskId = cleanString(input.taskId);
+  if (!taskId) {
+    throw new Error("Staged 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 workspace = input.workspace;
+  const artifactRoot = input.artifactRoot ?? resolve(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;
+  };
+  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(`
+`) || 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);
+        }
+      }
+    });
+    if (pr.status === "merged" && pr.prUrl) {
+      await runSourceCloseoutStage({
+        projectRoot: input.projectRoot,
+        taskId,
+        runId: input.runId,
+        pr,
+        ...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
+  };
+}
+export {
+  runStagedCloseout
+};

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

@@ -0,0 +1,11 @@
+import { type GitHubCommandRunner, type RigAutomationConfig } from "@rig/runtime/control-plane/native/pr-automation";
+import type { StrictPrMergeGateResult } from "@rig/runtime/control-plane/native/pr-review-gate";
+export type AutoMergeStageInput = {
+    readonly prUrl: string;
+    readonly config?: RigAutomationConfig;
+    readonly command: GitHubCommandRunner;
+    readonly cwd?: string;
+    readonly strictGate: StrictPrMergeGateResult;
+};
+export declare const autoMergeStage: import("./types").DefaultLifecycleStageDescriptor;
+export declare function runAutoMergeStage(input: AutoMergeStageInput): Promise<void>;

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

@@ -0,0 +1,27 @@
+// @bun
+// 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);
+}
+export {
+  runAutoMergeStage,
+  autoMergeStage
+};

package/dist/src/stages/commit.d.ts

@@ -0,0 +1,11 @@
+import { type GitCommandRunner } from "@rig/runtime/control-plane/native/pr-automation";
+export type CommitStageInput = {
+    readonly cwd: string;
+    readonly message: string;
+    readonly command: GitCommandRunner;
+};
+export declare const commitStage: import("./types").DefaultLifecycleStageDescriptor;
+export declare function runCommitStage(input: CommitStageInput): Promise<{
+    readonly committed: boolean;
+    readonly status: string;
+}>;

package/dist/src/stages/commit.js

@@ -0,0 +1,27 @@
+// @bun
+// packages/bundle-default-lifecycle/src/stages/commit.ts
+import { commitRunChanges } 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/commit.ts
+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);
+}
+export {
+  runCommitStage,
+  commitStage
+};

package/dist/src/stages/isolation.d.ts

@@ -0,0 +1,11 @@
+import { type AgentRuntime, type IsolationMode } from "@rig/runtime/control-plane/runtime/isolation";
+export type IsolationStageInput = {
+    readonly projectRoot: string;
+    readonly id: string;
+    readonly taskId: string;
+    readonly mode: IsolationMode;
+    readonly provider?: "pi";
+    readonly preserveTaskArtifacts?: boolean;
+};
+export declare const isolationStage: import("./types").DefaultLifecycleStageDescriptor;
+export declare function runIsolationStage(input: IsolationStageInput): Promise<AgentRuntime>;

package/dist/src/stages/isolation.js

@@ -0,0 +1,28 @@
+// @bun
+// packages/bundle-default-lifecycle/src/stages/isolation.ts
+import { ensureAgentRuntime } from "@rig/runtime/control-plane/runtime/isolation";
+
+// 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/isolation.ts
+var isolationStage = defineDefaultLifecycleStage({
+  id: "isolation",
+  kind: "transform",
+  description: "Provision the isolated runtime worktree through the runtime isolation subsystem.",
+  calls: ["ensureAgentRuntime"],
+  protected: true
+});
+async function runIsolationStage(input) {
+  return await ensureAgentRuntime(input);
+}
+export {
+  runIsolationStage,
+  isolationStage
+};

package/dist/src/stages/journal-append.d.ts

@@ -0,0 +1,7 @@
+import type { JournalCapability, RunJournalEventInit } from "@rig/contracts";
+export type JournalAppendStageInput = {
+    readonly journal: JournalCapability;
+    readonly event: RunJournalEventInit;
+};
+export declare const journalAppendStage: import("./types").DefaultLifecycleStageDescriptor;
+export declare function runJournalAppendStage(input: JournalAppendStageInput): Promise<void>;

package/dist/src/stages/journal-append.js

@@ -0,0 +1,25 @@
+// @bun
+// 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/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
+});
+async function runJournalAppendStage(input) {
+  await input.journal.append(input.event);
+}
+export {
+  runJournalAppendStage,
+  journalAppendStage
+};

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

@@ -0,0 +1 @@
+export declare const mergeGateStage: import("./types").DefaultLifecycleStageDescriptor;

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

@@ -0,0 +1,21 @@
+// @bun
+// 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/merge-gate.ts
+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
+});
+export {
+  mergeGateStage
+};

package/dist/src/stages/open-pr.d.ts

@@ -0,0 +1,9 @@
+import { type PrAutomationLifecycle, type PrAutomationResult, type RigAutomationConfig } from "@rig/runtime/control-plane/native/pr-automation";
+import type { InProcessCloseoutInput } from "@rig/runtime/control-plane/native/in-process-closeout";
+export type OpenPrStageInput = Omit<InProcessCloseoutInput, "config"> & {
+    readonly config?: RigAutomationConfig;
+    readonly lifecycle?: PrAutomationLifecycle;
+    readonly uploadedSnapshot?: boolean;
+};
+export declare const openPrStage: import("./types").DefaultLifecycleStageDescriptor;
+export declare function runOpenPrStage(input: OpenPrStageInput): Promise<PrAutomationResult>;

package/dist/src/stages/open-pr.js

@@ -0,0 +1,41 @@
+// @bun
+// packages/bundle-default-lifecycle/src/stages/open-pr.ts
+import { runPrAutomation } 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/open-pr.ts
+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 } : {}
+  });
+}
+export {
+  runOpenPrStage,
+  openPrStage
+};

package/dist/src/stages/push.d.ts

@@ -0,0 +1,8 @@
+import { type GitCommandRunner } from "@rig/runtime/control-plane/native/pr-automation";
+export type PushStageInput = {
+    readonly projectRoot: string;
+    readonly branch: string;
+    readonly gitCommand: GitCommandRunner;
+};
+export declare const pushStage: import("./types").DefaultLifecycleStageDescriptor;
+export declare function runPushStage(input: PushStageInput): Promise<void>;

package/dist/src/stages/push.js

@@ -0,0 +1,27 @@
+// @bun
+// packages/bundle-default-lifecycle/src/stages/push.ts
+import { pushBranchSyncedWithOrigin } 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/push.ts
+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);
+}
+export {
+  runPushStage,
+  pushStage
+};

package/dist/src/stages/source-closeout.d.ts

@@ -0,0 +1,18 @@
+import { type PrAutomationResult } from "@rig/runtime/control-plane/native/pr-automation";
+export type SourceCloseoutStageInput = {
+    readonly projectRoot: string;
+    readonly taskId: string;
+    readonly runId: string;
+    readonly pr: PrAutomationResult;
+    readonly sourceTask?: Record<string, unknown> | null;
+    readonly updateTaskSource: (projectRoot: string, input: {
+        readonly taskId: string;
+        readonly sourceTask?: Record<string, unknown> | null;
+        readonly update: {
+            readonly status: "closed";
+            readonly comment: string;
+        };
+    }) => Promise<unknown>;
+};
+export declare const sourceCloseoutStage: import("./types").DefaultLifecycleStageDescriptor;
+export declare function runSourceCloseoutStage(input: SourceCloseoutStageInput): Promise<void>;

package/dist/src/stages/source-closeout.js

@@ -0,0 +1,36 @@
+// @bun
+// packages/bundle-default-lifecycle/src/stages/source-closeout.ts
+import { closeIssueAfterMergedPr } 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/source-closeout.ts
+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 } : {}
+  });
+}
+export {
+  sourceCloseoutStage,
+  runSourceCloseoutStage
+};