@contractspec/lib.contracts-spec 2.0.0

package/dist/prompt.js

@@ -0,0 +1,38 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/prompt.ts
+function definePrompt(spec) {
+  return spec;
+}
+export {
+  definePrompt
+};

package/dist/prompt.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/promptRegistry.d.ts

@@ -0,0 +1,11 @@
+import type { PromptSpec } from './prompt';
+import * as z from 'zod';
+export declare class PromptRegistry {
+    private prompts;
+    /** Register a prompt. Throws on duplicate name+version. */
+    register<I extends z.ZodType>(p: PromptSpec<I>): this;
+    /** List all registered prompts. */
+    list(): PromptSpec<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>[];
+    /** Get prompt by name; when version omitted, returns highest version. */
+    get(name: string, version?: string): PromptSpec<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>> | undefined;
+}

package/dist/promptRegistry.js

@@ -0,0 +1,63 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/promptRegistry.ts
+import { compareVersions } from "compare-versions";
+
+class PromptRegistry {
+  prompts = new Map;
+  register(p) {
+    const key = `${p.meta.key}-v${p.meta.version}`;
+    if (this.prompts.has(key))
+      throw new Error(`Duplicate prompt ${key}`);
+    this.prompts.set(key, p);
+    return this;
+  }
+  list() {
+    return [...this.prompts.values()];
+  }
+  get(name, version) {
+    if (version != null)
+      return this.prompts.get(`${name}-v${version}`);
+    let candidate;
+    for (const [k, p] of this.prompts.entries()) {
+      if (!k.startsWith(`${name}.v`))
+        continue;
+      if (!candidate || compareVersions(p.meta.version, candidate.meta.version) > 0) {
+        candidate = p;
+      }
+    }
+    return candidate;
+  }
+}
+export {
+  PromptRegistry
+};

package/dist/promptRegistry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/regenerator/adapters.d.ts

@@ -0,0 +1,15 @@
+import type { BehaviorSignal, ErrorSignal, RegenerationContext, TelemetrySignal } from './types';
+export interface TelemetrySignalProvider {
+    pollTelemetry(context: RegenerationContext, since: Date, until: Date): Promise<TelemetrySignal[]>;
+}
+export interface ErrorSignalProvider {
+    pollErrors(context: RegenerationContext, since: Date, until: Date): Promise<ErrorSignal[]>;
+}
+export interface BehaviorSignalProvider {
+    pollBehavior(context: RegenerationContext, since: Date, until: Date): Promise<BehaviorSignal[]>;
+}
+export interface SignalAdapters {
+    telemetry?: TelemetrySignalProvider;
+    errors?: ErrorSignalProvider;
+    behavior?: BehaviorSignalProvider;
+}

package/dist/regenerator/adapters.js

@@ -0,0 +1 @@
+// @bun

package/dist/regenerator/docs/regenerator.docblock.d.ts

@@ -0,0 +1,2 @@
+import type { DocBlock } from '@contractspec/lib.contracts-spec/docs';
+export declare const tech_contracts_regenerator_DocBlocks: DocBlock[];

package/dist/regenerator/docs/regenerator.docblock.js

@@ -0,0 +1,164 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/docs/presentations.ts
+var DEFAULT_TARGETS = [
+  "markdown",
+  "react"
+];
+function normalizeRoute(route) {
+  if (!route.length)
+    return "/";
+  const withLeading = route.startsWith("/") ? route : `/${route}`;
+  return withLeading === "/" ? "/" : withLeading.replace(/\/+$/, "");
+}
+function deriveRoute(block, routePrefix) {
+  if (block.route)
+    return normalizeRoute(block.route);
+  const prefix = routePrefix ?? "/docs";
+  const slug = block.id.replace(/^docs\.?/, "").replace(/\./g, "/").replace(/\/+/g, "/");
+  const path = slug.startsWith("/") ? slug : `${prefix}/${slug}`;
+  return normalizeRoute(path);
+}
+function buildName(block, namespace) {
+  return namespace ? `${namespace}.${block.id}` : block.id;
+}
+function docBlockToPresentationSpec(block, options) {
+  const targets = options?.defaultTargets ?? DEFAULT_TARGETS;
+  const version = block.version ?? options?.defaultVersion ?? "1.0.0";
+  const stability = block.stability ?? options?.defaultStability ?? "stable";
+  return {
+    meta: {
+      key: buildName(block, options?.namespace),
+      title: block.title,
+      version,
+      description: block.summary ?? block.title,
+      tags: block.tags || [],
+      owners: block.owners || [],
+      domain: block.domain || "",
+      stability,
+      goal: `Documentation of: ${block.summary}`,
+      context: `Auto-generated`
+    },
+    policy: block.visibility && block.visibility !== "public" ? { flags: [block.visibility] } : undefined,
+    source: {
+      type: "blocknotejs",
+      docJson: block.body
+    },
+    targets
+  };
+}
+function docBlocksToPresentationRoutes(blocks, options) {
+  return blocks.map((block) => ({
+    block,
+    route: deriveRoute(block, options?.routePrefix),
+    descriptor: docBlockToPresentationSpec(block, options)
+  }));
+}
+function docBlocksToPresentationSpecs(blocks, options) {
+  return blocks.map((block) => docBlockToPresentationSpec(block, options));
+}
+function mapDocRoutes(routes) {
+  return routes.map(({ route, descriptor }) => [route, descriptor]);
+}
+
+// src/docs/registry.ts
+class DocRegistry {
+  routes = new Map;
+  constructor(blocks = [], options) {
+    blocks.forEach((block) => this.register(block, options));
+  }
+  register(block, options) {
+    const [route] = docBlocksToPresentationRoutes([block], options);
+    if (route) {
+      this.routes.set(block.id, route);
+    }
+    return this;
+  }
+  list() {
+    return [...this.routes.values()];
+  }
+  get(id) {
+    return this.routes.get(id);
+  }
+  toRouteTuples() {
+    return this.list().map(({ route, descriptor }) => [route, descriptor]);
+  }
+  toPresentationSpecs(options) {
+    return this.list().map(({ block }) => docBlockToPresentationSpec(block, options));
+  }
+}
+var requiredFields = [
+  "id",
+  "title",
+  "body",
+  "kind",
+  "visibility",
+  "route"
+];
+var defaultDocRegistry = new DocRegistry;
+function registerDocBlocks(blocks) {
+  for (const block of blocks) {
+    for (const field of requiredFields) {
+      if (!block[field]) {
+        throw new Error(`DocBlock ${block.id ?? "<missing id>"} missing field ${String(field)}`);
+      }
+    }
+    defaultDocRegistry.register(block);
+  }
+}
+function listRegisteredDocBlocks() {
+  return defaultDocRegistry.list().map((r) => r.block);
+}
+function docId(id) {
+  const found = defaultDocRegistry.get(id);
+  if (!found)
+    throw new Error(`DocBlock not registered: ${id}`);
+  return id;
+}
+
+// src/regenerator/docs/regenerator.docblock.ts
+var tech_contracts_regenerator_DocBlocks = [
+  {
+    id: "docs.tech.contracts.regenerator",
+    title: "Regenerator Service",
+    summary: "The Regenerator daemon observes telemetry, error, and behavior streams, then suggests spec-level changes (not code patches) that can be reviewed and applied through the App Studio.",
+    kind: "reference",
+    visibility: "public",
+    route: "/docs/tech/contracts/regenerator",
+    tags: ["tech", "contracts", "regenerator"],
+    body: "## Regenerator Service\n\nThe Regenerator daemon observes telemetry, error, and behavior streams, then suggests spec-level changes (not code patches) that can be reviewed and applied through the App Studio.\n\n- Runtime entrypoint: `packages/libs/contracts/src/regenerator/service.ts`\n- Types/interfaces: `packages/libs/contracts/src/regenerator/types.ts`\n- Signal adapters: `packages/libs/contracts/src/regenerator/adapters.ts`\n\n### Architecture\n\n```text\nSignal Adapters \u2500\u2500\u25BA RegeneratorService \u2500\u2500\u25BA Rules \u2500\u2500\u25BA ProposalSink\n          \u25B2                                       \u2502\n          \u2502                                       \u25BC\n     Telemetry / Errors / Behavior         Spec change proposals\n```\n\n1. **Signal adapters** pull batches of telemetry, error logs, or behavior metrics for each `RegenerationContext`.\n2. `RegeneratorService` schedules polling (`resolveAppConfig` + `composeAppConfig` provide context).\n3. **Rules** implement domain heuristics and emit `SpecChangeProposal` objects.\n4. **Proposal sinks** persist or forward proposals for human review.\n\n### Key types\n\n```ts\nexport interface RegenerationContext {\n  id: string;\n  blueprint: AppBlueprintSpec;\n  tenantConfig: TenantAppConfig;\n  resolved: ResolvedAppConfig;\n}\n\nexport interface RegeneratorRule {\n  id: string;\n  description: string;\n  evaluate(\n    context: RegenerationContext,\n    signals: RegeneratorSignal[]\n  ): Promise<SpecChangeProposal[]>;\n}\n\nexport interface SpecChangeProposal {\n  id: string;\n  title: string;\n  summary: string;\n  confidence: 'low' | 'medium' | 'high';\n  target: ProposalTarget;\n  actions: ProposalAction[];\n  blockers?: ProposalBlocker[];\n  signalIds: string[];\n  createdAt: Date;\n}\n```\n\n- Signals are normalized envelopes: telemetry (`count`, anomaly score), errors, and behavior trends.\n- Proposals reference blueprint or tenant specs via `ProposalTarget`.\n- Actions encode what the automation should perform (update blueprint, run tests/migrations, trigger regeneration).\n\n### Providing signals\n\nImplement `TelemetrySignalProvider`, `ErrorSignalProvider`, or `BehaviorSignalProvider`:\n\n```ts\nconst service = new RegeneratorService({\n  contexts,\n  adapters: {\n    telemetry: new PosthogTelemetryAdapter(),\n    errors: new SentryErrorAdapter(),\n  },\n  rules: [new WorkflowFailureRule(), new DataViewUsageRule()],\n  sink: new ProposalQueueSink(),\n  pollIntervalMs: 60_000,\n});\n```\n\nAdapters receive the full `RegenerationContext`, making it easy to scope queries per tenant/app.\n\n### Authoring rules\n\nRules focus on signals \u2192 proposals:\n\n```ts\nclass WorkflowFailureRule implements RegeneratorRule {\n  id = 'workflow-failure';\n  description = 'Suggest splitting workflows that exceed failure thresholds';\n\n  async evaluate(context, signals) {\n    const failures = signals.filter(\n      (signal) =>\n        signal.type === 'telemetry' &&\n        signal.signal.eventName === 'workflow.failure' &&\n        signal.signal.count >= 10\n    );\n\n    if (failures.length === 0) return [];\n\n    return [\n      {\n        id: `${this.id}-${context.id}`,\n        title: 'Split onboarding workflow',\n        summary: 'Step 3 fails consistently; propose dedicated remediation branch.',\n        confidence: 'medium',\n        rationale: ['Failure count \u2265 10 within last window'],\n        target: {\n          specType: 'workflow',\n          reference: { name: 'onboarding.workflow', version: '1.0.0' },\n          tenantScoped: true,\n        },\n        actions: [\n          { kind: 'update_tenant_config', summary: 'Add alternate fallback path' },\n          { kind: 'run_tests', tests: ['workflows/onboarding.spec.ts'] },\n        ],\n        signalIds: failures.map((f) => f.signal.eventName),\n        createdAt: new Date(),\n      },\n    ];\n  }\n}\n```\n\n### Reviewing proposals\n\nProposals flow to a `ProposalSink` (queue, DB, messaging bus). The Studio will surface:\n\n1. Signal evidence (telemetry counts, error metadata)\n2. Proposed spec diffs and required actions (tests/migrations)\n3. Approval workflow (approve \u2192 write spec diff \u2192 run automation)\n\n### CLI driver\n\nRun the regenerator daemon from the CLI:\n\n```bash\nbunx contracts regenerator ./app.blueprint.ts ./tenant.config.ts ./regenerator.rules.ts auto \\\n  --executor ./regenerator.executor.ts \\\n  --poll-interval 60000 \\\n  --batch-duration 300000 \\\n  --dry-run\n```\n\n- Expects modules exporting default `AppBlueprintSpec`, `TenantAppConfig`, and one or more `RegenerationRule`s.\n- Pass a sink module path, or use the special `auto` value with `--executor <module>` to instantiate an `ExecutorProposalSink`.\n- Executor modules can export a `ProposalExecutor` instance, a factory, or a plain dependency object for the executor constructor. Optional exports: `sinkOptions`, `logger`, `onResult`, `dryRun`.\n- Optionally provide `--contexts ./contexts.ts` to load custom context arrays (advanced multi-tenant scenarios).\n- Use `--dry-run` to preview actions without mutating specs/configs, and `--once` for CI smoke tests.\n\n### Proposal executor\n\n`ProposalExecutor` + `ExecutorProposalSink` orchestrate follow-up actions once a proposal is approved:\n\n- Interfaces for applying blueprint or tenant-config updates (`BlueprintUpdater`, `TenantConfigUpdater`).\n- Hooks for running contract tests and migrations (`TestExecutor`, `MigrationExecutor`).\n- Optional trigger to recompose the runtime (`RegenerationTrigger`).\n- Built-in `dryRun` mode to preview outcomes.\n- Pluggable result logging/forwarding via `ExecutorSinkOptions`.\n\n```ts\nimport {\n  ProposalExecutor,\n  ExecutorProposalSink,\n} from '@contractspec/lib.contracts-spec/regenerator';\n\nconst executor = new ProposalExecutor({\n  tenantConfigUpdater,\n  testExecutor,\n  migrationExecutor,\n  regenerationTrigger,\n});\n\nconst sink = new ExecutorProposalSink(executor, {\n  dryRun: false,\n  onResult: ({ result }) => console.log(result.status),\n});\n```\n\nExecution results include per-action status (`success`, `skipped`, `failed`) plus aggregated proposal status (`success`, `partial`, `failed`). Missing dependencies mark actions as `skipped`, making it easy to plug into partial automation flows today and extend later.\n\n### Next steps\n\n- Build adapters for existing telemetry/error providers.\n- Encode canonical rules (workflow failure, feature under-use, high latency).\n- Integrate with App Studio proposal inbox and automate acceptance (write spec diff, run tests, queue migrations).\n\n"
+  }
+];
+registerDocBlocks(tech_contracts_regenerator_DocBlocks);
+export {
+  tech_contracts_regenerator_DocBlocks
+};

package/dist/regenerator/executor.d.ts

@@ -0,0 +1,66 @@
+import type { SpecChangeProposal, ProposalAction, RegenerationContext } from './types';
+export type ExecutionStatus = 'success' | 'skipped' | 'failed';
+export interface ActionExecutionResult {
+    index: number;
+    action: ProposalAction;
+    status: ExecutionStatus;
+    startedAt: Date;
+    finishedAt: Date;
+    reason?: string;
+    error?: Error;
+    output?: unknown;
+}
+export interface ProposalExecutionResult {
+    proposalId: string;
+    contextId: string;
+    startedAt: Date;
+    finishedAt: Date;
+    status: 'success' | 'partial' | 'failed';
+    actions: ActionExecutionResult[];
+}
+export type UpdateBlueprintAction = Extract<ProposalAction, {
+    kind: 'update_blueprint';
+}>;
+export type UpdateTenantConfigAction = Extract<ProposalAction, {
+    kind: 'update_tenant_config';
+}>;
+export type RunTestsAction = Extract<ProposalAction, {
+    kind: 'run_tests';
+}>;
+export type RunMigrationsAction = Extract<ProposalAction, {
+    kind: 'run_migrations';
+}>;
+export type TriggerRegenerationAction = Extract<ProposalAction, {
+    kind: 'trigger_regeneration';
+}>;
+export interface BlueprintUpdater {
+    applyBlueprintUpdate(context: RegenerationContext, proposal: SpecChangeProposal, action: UpdateBlueprintAction): Promise<unknown>;
+}
+export interface TenantConfigUpdater {
+    applyTenantConfigUpdate(context: RegenerationContext, proposal: SpecChangeProposal, action: UpdateTenantConfigAction): Promise<unknown>;
+}
+export interface TestExecutor {
+    runTests(context: RegenerationContext, proposal: SpecChangeProposal, action: RunTestsAction): Promise<unknown>;
+}
+export interface MigrationExecutor {
+    runMigrations(context: RegenerationContext, proposal: SpecChangeProposal, action: RunMigrationsAction): Promise<unknown>;
+}
+export interface RegenerationTrigger {
+    triggerRegeneration(context: RegenerationContext, proposal: SpecChangeProposal, action: TriggerRegenerationAction): Promise<unknown>;
+}
+export interface ProposalExecutorOptions {
+    dryRun?: boolean;
+}
+export interface ProposalExecutorDeps {
+    blueprintUpdater?: BlueprintUpdater;
+    tenantConfigUpdater?: TenantConfigUpdater;
+    testExecutor?: TestExecutor;
+    migrationExecutor?: MigrationExecutor;
+    regenerationTrigger?: RegenerationTrigger;
+}
+export declare class ProposalExecutor {
+    private readonly deps;
+    constructor(deps?: ProposalExecutorDeps);
+    execute(context: RegenerationContext, proposal: SpecChangeProposal, options?: ProposalExecutorOptions): Promise<ProposalExecutionResult>;
+    private executeAction;
+}

package/dist/regenerator/executor.js

@@ -0,0 +1,157 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/regenerator/executor.ts
+class ProposalExecutor {
+  deps;
+  constructor(deps = {}) {
+    this.deps = deps;
+  }
+  async execute(context, proposal, options = {}) {
+    const startedAt = new Date;
+    const actionResults = [];
+    for (const [index, action] of proposal.actions.entries()) {
+      const result = await this.executeAction({
+        index,
+        action,
+        context,
+        proposal,
+        options
+      });
+      actionResults.push(result);
+    }
+    const finishedAt = new Date;
+    const summaryStatus = summarizeStatus(actionResults);
+    return {
+      proposalId: proposal.id,
+      contextId: context.id,
+      startedAt,
+      finishedAt,
+      status: summaryStatus,
+      actions: actionResults
+    };
+  }
+  async executeAction({
+    index,
+    action,
+    context,
+    proposal,
+    options
+  }) {
+    const startedAt = new Date;
+    const dryRun = options.dryRun ?? false;
+    const complete = (status, params = {}) => ({
+      index,
+      action,
+      status,
+      startedAt,
+      finishedAt: new Date,
+      reason: params.reason,
+      output: params.output,
+      error: params.error
+    });
+    if (dryRun) {
+      return complete("skipped", { reason: "dry_run" });
+    }
+    try {
+      switch (action.kind) {
+        case "update_blueprint": {
+          const updater = this.deps.blueprintUpdater;
+          if (!updater) {
+            return complete("skipped", { reason: "missing_blueprint_updater" });
+          }
+          const output = await updater.applyBlueprintUpdate(context, proposal, action);
+          return complete("success", { output });
+        }
+        case "update_tenant_config": {
+          const updater = this.deps.tenantConfigUpdater;
+          if (!updater) {
+            return complete("skipped", {
+              reason: "missing_tenant_config_updater"
+            });
+          }
+          const output = await updater.applyTenantConfigUpdate(context, proposal, action);
+          return complete("success", { output });
+        }
+        case "run_tests": {
+          const executor = this.deps.testExecutor;
+          if (!executor) {
+            return complete("skipped", { reason: "missing_test_executor" });
+          }
+          const output = await executor.runTests(context, proposal, action);
+          return complete("success", { output });
+        }
+        case "run_migrations": {
+          const executor = this.deps.migrationExecutor;
+          if (!executor) {
+            return complete("skipped", {
+              reason: "missing_migration_executor"
+            });
+          }
+          const output = await executor.runMigrations(context, proposal, action);
+          return complete("success", { output });
+        }
+        case "trigger_regeneration": {
+          const trigger = this.deps.regenerationTrigger;
+          if (!trigger) {
+            return complete("skipped", {
+              reason: "missing_regeneration_trigger"
+            });
+          }
+          const output = await trigger.triggerRegeneration(context, proposal, action);
+          return complete("success", { output });
+        }
+        default: {
+          return complete("skipped", { reason: "unknown_action" });
+        }
+      }
+    } catch (error) {
+      return complete("failed", {
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+    }
+  }
+}
+function summarizeStatus(actionResults) {
+  if (actionResults.some((result) => result.status === "failed")) {
+    return "failed";
+  }
+  if (actionResults.some((result) => result.status === "success") && actionResults.some((result) => result.status === "skipped")) {
+    return "partial";
+  }
+  if (actionResults.every((result) => result.status === "skipped")) {
+    return "partial";
+  }
+  return "success";
+}
+export {
+  ProposalExecutor
+};

package/dist/regenerator/executor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/regenerator/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './adapters';
+export * from './service';
+export * from './executor';
+export * from './utils';
+export * from './sinks';