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

package/README.md

@@ -0,0 +1 @@
+# @h-rig/bundle-default-lifecycle

package/dist/src/closeoutEquivalence.d.ts

@@ -0,0 +1,37 @@
+import type { InProcessCloseoutResult } from "@rig/runtime/control-plane/native/in-process-closeout";
+export declare const CLOSEOUT_EQUIVALENCE_ARTIFACTS: readonly ["review-status.txt", "review-feedback.md", "review-state.json", "pr-state.json", "git-state.txt", "validation-summary.json"];
+export declare const CLOSEOUT_EQUIVALENCE_STATE_FILES: readonly ["task-repo-commits.json", "failed_approaches.md"];
+export type CloseoutEquivalenceArtifactName = typeof CLOSEOUT_EQUIVALENCE_ARTIFACTS[number] | typeof CLOSEOUT_EQUIVALENCE_STATE_FILES[number];
+export type CloseoutArtifactSnapshot = Readonly<Record<CloseoutEquivalenceArtifactName, string | null>>;
+export type CloseoutTaskSourceCall = {
+    readonly method: string;
+    readonly taskId: string;
+    readonly status?: string;
+    readonly summary?: string;
+};
+export type CloseoutEquivalenceRun = {
+    readonly label: "imperative" | "staged";
+    readonly result: InProcessCloseoutResult;
+    readonly artifacts: CloseoutArtifactSnapshot;
+    readonly taskSourceCalls: readonly CloseoutTaskSourceCall[];
+};
+export type CloseoutEquivalenceDiff = {
+    readonly kind: "artifact" | "task-source" | "result";
+    readonly path: string;
+    readonly imperative: string | null;
+    readonly staged: string | null;
+};
+export type CloseoutEquivalenceReport = {
+    readonly equivalent: boolean;
+    readonly diffs: readonly CloseoutEquivalenceDiff[];
+};
+export declare function snapshotCloseoutArtifacts(input: {
+    readonly projectRoot: string;
+    readonly taskId: string;
+    readonly artifactRoot?: string;
+    readonly stateRoot?: string;
+}): CloseoutArtifactSnapshot;
+export declare function compareCloseoutEquivalence(input: {
+    readonly imperative: CloseoutEquivalenceRun;
+    readonly staged: CloseoutEquivalenceRun;
+}): CloseoutEquivalenceReport;

package/dist/src/closeoutEquivalence.js

@@ -0,0 +1,78 @@
+// @bun
+// packages/bundle-default-lifecycle/src/closeoutEquivalence.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+var CLOSEOUT_EQUIVALENCE_ARTIFACTS = [
+  "review-status.txt",
+  "review-feedback.md",
+  "review-state.json",
+  "pr-state.json",
+  "git-state.txt",
+  "validation-summary.json"
+];
+var CLOSEOUT_EQUIVALENCE_STATE_FILES = [
+  "task-repo-commits.json",
+  "failed_approaches.md"
+];
+function snapshotCloseoutArtifacts(input) {
+  const artifactRoot = input.artifactRoot ?? resolve(input.projectRoot, "artifacts", input.taskId);
+  const stateRoot = input.stateRoot ?? resolve(input.projectRoot, ".rig", "state");
+  const entries = [
+    ...CLOSEOUT_EQUIVALENCE_ARTIFACTS.map((name) => {
+      const path = resolve(artifactRoot, name);
+      return [name, existsSync(path) ? readFileSync(path, "utf-8") : null];
+    }),
+    ...CLOSEOUT_EQUIVALENCE_STATE_FILES.map((name) => {
+      const path = resolve(stateRoot, name);
+      return [name, existsSync(path) ? readFileSync(path, "utf-8") : null];
+    })
+  ];
+  return Object.fromEntries(entries);
+}
+function compareCloseoutEquivalence(input) {
+  const diffs = [];
+  for (const name of [...CLOSEOUT_EQUIVALENCE_ARTIFACTS, ...CLOSEOUT_EQUIVALENCE_STATE_FILES]) {
+    const imperative = input.imperative.artifacts[name];
+    const staged = input.staged.artifacts[name];
+    if (imperative !== staged) {
+      diffs.push({ kind: "artifact", path: name, imperative, staged });
+    }
+  }
+  const imperativeCalls = JSON.stringify(input.imperative.taskSourceCalls.map((call) => ({
+    method: call.method,
+    taskId: call.taskId,
+    status: call.status ?? null,
+    summary: call.summary ?? null
+  })));
+  const stagedCalls = JSON.stringify(input.staged.taskSourceCalls.map((call) => ({
+    method: call.method,
+    taskId: call.taskId,
+    status: call.status ?? null,
+    summary: call.summary ?? null
+  })));
+  if (imperativeCalls !== stagedCalls) {
+    diffs.push({ kind: "task-source", path: "task-source-calls", imperative: imperativeCalls, staged: stagedCalls });
+  }
+  const imperativeResult = JSON.stringify({
+    status: input.imperative.result.status,
+    prUrl: input.imperative.result.prUrl ?? null,
+    iterations: input.imperative.result.iterations,
+    feedback: [...input.imperative.result.feedback]
+  });
+  const stagedResult = JSON.stringify({
+    status: input.staged.result.status,
+    prUrl: input.staged.result.prUrl ?? null,
+    iterations: input.staged.result.iterations,
+    feedback: [...input.staged.result.feedback]
+  });
+  if (imperativeResult !== stagedResult) {
+    diffs.push({ kind: "result", path: "closeout-result", imperative: imperativeResult, staged: stagedResult });
+  }
+  return { equivalent: diffs.length === 0, diffs };
+}
+export {
+  snapshotCloseoutArtifacts,
+  compareCloseoutEquivalence,
+  CLOSEOUT_EQUIVALENCE_STATE_FILES,
+  CLOSEOUT_EQUIVALENCE_ARTIFACTS
+};

package/dist/src/closeoutShadowHarness.d.ts

@@ -0,0 +1,27 @@
+export type CloseoutShadowEffectKind = "git-push" | "pr-open" | "review-gate" | "merge" | "task-source";
+export type CloseoutShadowEffect = {
+    readonly kind: CloseoutShadowEffectKind;
+    readonly target: string;
+    readonly detail?: string;
+};
+export type CloseoutShadowRun = {
+    readonly label: "imperative" | "staged";
+    readonly effects: readonly CloseoutShadowEffect[];
+};
+export type CloseoutShadowDiff = {
+    readonly index: number;
+    readonly imperative: CloseoutShadowEffect | null;
+    readonly staged: CloseoutShadowEffect | null;
+};
+export type CloseoutShadowComparison = {
+    readonly equivalent: boolean;
+    readonly diffs: readonly CloseoutShadowDiff[];
+};
+export declare function compareCloseoutShadowRuns(input: {
+    readonly imperative: CloseoutShadowRun;
+    readonly staged: CloseoutShadowRun;
+}): CloseoutShadowComparison;
+export declare function assertCloseoutShadowEquivalent(input: {
+    readonly imperative: CloseoutShadowRun;
+    readonly staged: CloseoutShadowRun;
+}): CloseoutShadowComparison;

package/dist/src/closeoutShadowHarness.js

@@ -0,0 +1,29 @@
+// @bun
+// packages/bundle-default-lifecycle/src/closeoutShadowHarness.ts
+function effectKey(effect) {
+  return effect === null ? null : JSON.stringify({ kind: effect.kind, target: effect.target, detail: effect.detail ?? null });
+}
+function compareCloseoutShadowRuns(input) {
+  const max = Math.max(input.imperative.effects.length, input.staged.effects.length);
+  const diffs = [];
+  for (let index = 0;index < max; index += 1) {
+    const imperative = input.imperative.effects[index] ?? null;
+    const staged = input.staged.effects[index] ?? null;
+    if (effectKey(imperative) !== effectKey(staged)) {
+      diffs.push({ index, imperative, staged });
+    }
+  }
+  return { equivalent: diffs.length === 0, diffs };
+}
+function assertCloseoutShadowEquivalent(input) {
+  const comparison = compareCloseoutShadowRuns(input);
+  if (!comparison.equivalent) {
+    const details = comparison.diffs.map((diff) => `#${diff.index}: imperative=${effectKey(diff.imperative) ?? "<missing>"} staged=${effectKey(diff.staged) ?? "<missing>"}`).join("; ");
+    throw new Error(`Closeout shadow side effects differ: ${details}`);
+  }
+  return comparison;
+}
+export {
+  compareCloseoutShadowRuns,
+  assertCloseoutShadowEquivalent
+};

package/dist/src/defaultPipeline.d.ts

@@ -0,0 +1,32 @@
+import type { ProtectedStageGrant, StageMutation } from "@rig/contracts";
+import { type KernelStageResolverResult } from "@rig/kernel/resolver";
+import type { DefaultLifecycleStageDescriptor, DefaultLifecycleStageId } from "./stages/types";
+export declare const DEFAULT_LIFECYCLE_STAGE_IDS: readonly ["validate", "verify", "commit", "push", "open-pr", "merge-gate", "auto-merge", "source-closeout", "isolation", "journal-append"];
+export declare const PROTECTED_DEFAULT_LIFECYCLE_STAGE_IDS: readonly ["merge-gate", "isolation", "journal-append"];
+export declare const defaultLifecycleStages: readonly [DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor, DefaultLifecycleStageDescriptor];
+export type ResolveDefaultLifecycleInput = {
+    readonly mutations?: readonly StageMutation[];
+    readonly protectedStageGrants?: readonly ProtectedStageGrant[];
+};
+export declare function defaultLifecycleStageById(id: DefaultLifecycleStageId): DefaultLifecycleStageDescriptor;
+export declare function resolveDefaultLifecycle(input?: ResolveDefaultLifecycleInput): KernelStageResolverResult;
+export type PipelineShowStage = {
+    readonly index: number | null;
+    readonly id: string;
+    readonly contributedBy: string;
+    readonly protected: boolean;
+    readonly removedBy?: string;
+    readonly replacedBy?: string;
+    readonly wrappedBy: readonly string[];
+    readonly droppedAnchors: readonly string[];
+};
+export type PipelineShowData = {
+    readonly title: string;
+    readonly stageCount: number;
+    readonly stages: readonly PipelineShowStage[];
+    readonly droppedAnchors: readonly string[];
+    readonly cycles: readonly (readonly string[])[];
+    readonly resolvedAt?: string;
+};
+export declare function defaultPipelineShowData(input?: ResolveDefaultLifecycleInput): PipelineShowData;
+export declare function formatDefaultPipelineShow(input?: ResolveDefaultLifecycleInput): string;

package/dist/src/defaultPipeline.js

@@ -0,0 +1,191 @@
+// @bun
+// 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"]
+});
+
+// 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"]
+});
+
+// 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"]
+});
+
+// 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"]
+});
+
+// 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"]
+});
+
+// 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_LIFECYCLE_STAGE_IDS = [
+  "validate",
+  "verify",
+  "commit",
+  "push",
+  "open-pr",
+  "merge-gate",
+  "auto-merge",
+  "source-closeout",
+  "isolation",
+  "journal-append"
+];
+var PROTECTED_DEFAULT_LIFECYCLE_STAGE_IDS = ["merge-gate", "isolation", "journal-append"];
+var defaultLifecycleStages = [
+  validateStage,
+  verifyStage,
+  commitStage,
+  pushStage,
+  openPrStage,
+  mergeGateStage,
+  autoMergeStage,
+  sourceCloseoutStage,
+  isolationStage,
+  journalAppendStage
+];
+function defaultLifecycleStageById(id) {
+  const stage = defaultLifecycleStages.find((candidate) => candidate.id === id);
+  if (!stage)
+    throw new Error(`Unknown default lifecycle stage: ${id}`);
+  return stage;
+}
+function resolveDefaultLifecycle(input = {}) {
+  const grants = { protectedStageGrants: input.protectedStageGrants ?? [] };
+  return resolveKernelStages(defaultLifecycleStages, input.mutations ?? [], grants);
+}
+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,
+    protected: entry.isProtected,
+    ...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 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" : ""}`);
+      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);
+    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(`
+`);
+}
+export {
+  resolveDefaultLifecycle,
+  formatDefaultPipelineShow,
+  defaultPipelineShowData,
+  defaultLifecycleStages,
+  defaultLifecycleStageById,
+  PROTECTED_DEFAULT_LIFECYCLE_STAGE_IDS,
+  DEFAULT_LIFECYCLE_STAGE_IDS
+};

package/dist/src/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./closeoutEquivalence";
+export * from "./closeoutShadowHarness";
+export * from "./defaultPipeline";
+export * from "./stagedCloseout";
+export * from "./plugin";
+export * from "./stages/auto-merge";
+export * from "./stages/commit";
+export * from "./stages/isolation";
+export * from "./stages/journal-append";
+export * from "./stages/merge-gate";
+export * from "./stages/open-pr";
+export * from "./stages/push";
+export * from "./stages/source-closeout";
+export * from "./stages/types";
+export * from "./stages/validate";
+export * from "./stages/verify";