@manifesto-ai/governance 3.1.2 → 3.3.1

package/dist/chunk-JLXJCLOD.js

@@ -0,0 +1,1020 @@
+// src/types.ts
+function createProposalId(value) {
+  return value ?? `prop-${crypto.randomUUID()}`;
+}
+function createDecisionId(value) {
+  return value ?? `dec-${crypto.randomUUID()}`;
+}
+function createExecutionKey(proposalId, attempt = 1) {
+  return `${proposalId}:${attempt}`;
+}
+var defaultExecutionKeyPolicy = ({
+  proposalId,
+  attempt
+}) => createExecutionKey(proposalId, attempt);
+function createNoopGovernanceEventSink() {
+  return {
+    emit() {
+    }
+  };
+}
+function toHostIntent(intent) {
+  if ("body" in intent) {
+    return {
+      type: intent.body.type,
+      input: intent.body.input,
+      intentId: intent.intentId
+    };
+  }
+  return {
+    type: intent.type,
+    input: intent.input,
+    intentId: intent.intentId
+  };
+}
+
+// src/state-machine.ts
+var INGRESS_STATUSES = ["submitted", "evaluating"];
+var EXECUTION_STAGE_STATUSES = ["approved", "executing"];
+var TERMINAL_STATUSES = ["rejected", "completed", "failed", "superseded"];
+var DECISION_TRANSITION_TARGETS = ["approved", "rejected"];
+var VALID_TRANSITIONS = {
+  submitted: ["evaluating", "rejected", "superseded"],
+  evaluating: ["approved", "rejected", "superseded"],
+  approved: ["executing"],
+  rejected: [],
+  executing: ["completed", "failed"],
+  completed: [],
+  failed: [],
+  superseded: []
+};
+function isIngressStatus(status) {
+  return INGRESS_STATUSES.includes(status);
+}
+function isExecutionStageStatus(status) {
+  return EXECUTION_STAGE_STATUSES.includes(status);
+}
+function isTerminalStatus(status) {
+  return TERMINAL_STATUSES.includes(status);
+}
+function isValidTransition(from, to) {
+  return VALID_TRANSITIONS[from].includes(to);
+}
+function getValidTransitions(status) {
+  return [...VALID_TRANSITIONS[status]];
+}
+function transitionCreatesDecisionRecord(from, to) {
+  return from === "submitted" && to === "rejected" || from === "evaluating" && to === "approved" || from === "evaluating" && to === "rejected";
+}
+
+// src/store/in-memory-governance-store.ts
+function cloneValue(value) {
+  return structuredClone(value);
+}
+var InMemoryGovernanceStore = class {
+  proposals = /* @__PURE__ */ new Map();
+  decisions = /* @__PURE__ */ new Map();
+  actorBindings = /* @__PURE__ */ new Map();
+  async putProposal(proposal) {
+    this.proposals.set(proposal.proposalId, cloneValue(proposal));
+  }
+  async getProposal(proposalId) {
+    return cloneValue(this.proposals.get(proposalId) ?? null);
+  }
+  async getProposalsByBranch(branchId) {
+    return [...this.proposals.values()].filter((proposal) => proposal.branchId === branchId).sort((left, right) => {
+      if (left.submittedAt !== right.submittedAt) {
+        return left.submittedAt - right.submittedAt;
+      }
+      return left.proposalId.localeCompare(right.proposalId);
+    }).map((proposal) => cloneValue(proposal));
+  }
+  async getExecutionStageProposal(branchId) {
+    const matches = (await this.getProposalsByBranch(branchId)).filter(
+      (proposal) => isExecutionStageStatus(proposal.status)
+    );
+    if (matches.length > 1) {
+      throw new Error(
+        `GOV-STORE-4 violation: multiple execution-stage proposals found for branch ${branchId}`
+      );
+    }
+    return matches[0] ?? null;
+  }
+  async putDecisionRecord(record) {
+    this.decisions.set(record.decisionId, cloneValue(record));
+  }
+  async getDecisionRecord(decisionId) {
+    return cloneValue(this.decisions.get(decisionId) ?? null);
+  }
+  async putActorBinding(binding) {
+    this.actorBindings.set(binding.actorId, cloneValue(binding));
+  }
+  async getActorBinding(actorId) {
+    return cloneValue(this.actorBindings.get(actorId) ?? null);
+  }
+  async getActorBindings() {
+    return [...this.actorBindings.values()].sort((left, right) => left.actorId.localeCompare(right.actorId)).map((binding) => cloneValue(binding));
+  }
+  snapshotState() {
+    return {
+      proposals: cloneValue(this.proposals),
+      decisions: cloneValue(this.decisions),
+      actorBindings: cloneValue(this.actorBindings)
+    };
+  }
+  restoreState(state) {
+    this.proposals.clear();
+    for (const [proposalId, proposal] of state.proposals) {
+      this.proposals.set(proposalId, cloneValue(proposal));
+    }
+    this.decisions.clear();
+    for (const [decisionId, record] of state.decisions) {
+      this.decisions.set(decisionId, cloneValue(record));
+    }
+    this.actorBindings.clear();
+    for (const [actorId, binding] of state.actorBindings) {
+      this.actorBindings.set(actorId, cloneValue(binding));
+    }
+  }
+};
+function createInMemoryGovernanceStore() {
+  return new InMemoryGovernanceStore();
+}
+
+// src/authority/auto.ts
+var AutoApproveHandler = class {
+  async evaluate(proposal, binding) {
+    if (binding.policy.mode !== "auto_approve") {
+      throw new Error(
+        `AutoApproveHandler received non-auto_approve policy: ${binding.policy.mode}`
+      );
+    }
+    return {
+      kind: "approved",
+      approvedScope: proposal.intent.scopeProposal ?? null
+    };
+  }
+};
+function createAutoApproveHandler() {
+  return new AutoApproveHandler();
+}
+
+// src/authority/hitl.ts
+var HITLHandler = class {
+  pendingDecisions = /* @__PURE__ */ new Map();
+  notificationCallbacks = /* @__PURE__ */ new Set();
+  onPendingDecision(callback) {
+    this.notificationCallbacks.add(callback);
+    return () => {
+      this.notificationCallbacks.delete(callback);
+    };
+  }
+  async evaluate(proposal, binding) {
+    if (binding.policy.mode !== "hitl") {
+      throw new Error(`HITLHandler received non-hitl policy: ${binding.policy.mode}`);
+    }
+    const policy = binding.policy;
+    const proposalId = proposal.proposalId;
+    if (this.pendingDecisions.has(proposalId)) {
+      throw new Error(`Proposal ${proposalId} already has a pending HITL decision`);
+    }
+    return new Promise((resolve, reject) => {
+      const state = {
+        proposalId,
+        proposal,
+        resolve,
+        reject
+      };
+      if (policy.timeout != null) {
+        state.timeoutId = setTimeout(() => {
+          this.pendingDecisions.delete(proposalId);
+          if (policy.onTimeout === "approve") {
+            resolve({
+              kind: "approved",
+              approvedScope: proposal.intent.scopeProposal ?? null
+            });
+            return;
+          }
+          reject(
+            new Error(
+              `HITL decision timed out after ${policy.timeout}ms for proposal '${proposalId}'`
+            )
+          );
+        }, policy.timeout);
+      }
+      this.pendingDecisions.set(proposalId, state);
+      for (const callback of this.notificationCallbacks) {
+        callback(proposalId, proposal, binding);
+      }
+    });
+  }
+  submitDecision(proposalId, decision, reasoning, approvedScope) {
+    const state = this.pendingDecisions.get(proposalId);
+    if (!state) {
+      throw new Error(`No pending HITL decision for proposal ${proposalId}`);
+    }
+    if (state.timeoutId) {
+      clearTimeout(state.timeoutId);
+    }
+    this.pendingDecisions.delete(proposalId);
+    if (decision === "approved") {
+      state.resolve({
+        kind: "approved",
+        approvedScope: approvedScope !== void 0 ? approvedScope : state.proposal?.intent.scopeProposal ?? null
+      });
+      return;
+    }
+    state.resolve({
+      kind: "rejected",
+      reason: reasoning ?? "Human rejected"
+    });
+  }
+  isPending(proposalId) {
+    return this.pendingDecisions.has(proposalId);
+  }
+  getPendingIds() {
+    return [...this.pendingDecisions.keys()];
+  }
+  clearAllPending() {
+    for (const [proposalId, state] of this.pendingDecisions) {
+      if (state.timeoutId) {
+        clearTimeout(state.timeoutId);
+      }
+      state.reject(new Error(`HITL handler cleared pending proposal ${proposalId}`));
+    }
+    this.pendingDecisions.clear();
+  }
+};
+function createHITLHandler() {
+  return new HITLHandler();
+}
+
+// src/authority/policy.ts
+var PolicyRulesHandler = class {
+  customEvaluators = /* @__PURE__ */ new Map();
+  registerCustomEvaluator(name, evaluator) {
+    this.customEvaluators.set(name, evaluator);
+  }
+  async evaluate(proposal, binding) {
+    if (binding.policy.mode !== "policy_rules") {
+      throw new Error(
+        `PolicyRulesHandler received non-policy_rules policy: ${binding.policy.mode}`
+      );
+    }
+    const approvedScope = proposal.intent.scopeProposal ?? null;
+    for (const rule of binding.policy.rules) {
+      if (this.evaluateCondition(rule.condition, proposal, binding)) {
+        return this.applyDecision(rule, approvedScope);
+      }
+    }
+    return this.applyDecision(
+      {
+        decision: binding.policy.defaultDecision,
+        reason: "Default policy decision"
+      },
+      approvedScope
+    );
+  }
+  evaluateCondition(condition, proposal, binding) {
+    switch (condition.kind) {
+      case "intent_type":
+        return condition.types.includes(proposal.intent.type);
+      case "scope_pattern":
+        return this.matchPattern(proposal.intent.type, condition.pattern);
+      case "custom": {
+        const evaluator = this.customEvaluators.get(condition.evaluator);
+        return evaluator ? evaluator(proposal, binding) : false;
+      }
+    }
+  }
+  matchPattern(value, pattern) {
+    const regex = new RegExp(
+      `^${pattern.replace(/\*/g, ".*").replace(/\?/g, ".")}$`
+    );
+    return regex.test(value);
+  }
+  applyDecision(rule, approvedScope) {
+    switch (rule.decision) {
+      case "approve":
+        return { kind: "approved", approvedScope };
+      case "reject":
+        return { kind: "rejected", reason: rule.reason ?? "Policy rejection" };
+      case "escalate":
+        return {
+          kind: "rejected",
+          reason: rule.reason ?? "Policy requires escalation (not implemented)"
+        };
+    }
+  }
+};
+function createPolicyRulesHandler() {
+  return new PolicyRulesHandler();
+}
+
+// src/authority/tribunal.ts
+var TribunalHandler = class {
+  pendingTribunals = /* @__PURE__ */ new Map();
+  notificationCallback;
+  onPendingTribunal(callback) {
+    this.notificationCallback = callback;
+  }
+  async evaluate(proposal, binding) {
+    if (binding.policy.mode !== "tribunal") {
+      throw new Error(
+        `TribunalHandler received non-tribunal policy: ${binding.policy.mode}`
+      );
+    }
+    const policy = binding.policy;
+    const proposalId = proposal.proposalId;
+    if (this.pendingTribunals.has(proposalId)) {
+      throw new Error(`Proposal ${proposalId} already has a pending tribunal`);
+    }
+    return new Promise((resolve, reject) => {
+      const state = {
+        proposalId,
+        proposal,
+        binding,
+        votes: /* @__PURE__ */ new Map(),
+        resolve,
+        reject
+      };
+      if (policy.timeout != null) {
+        state.timeoutId = setTimeout(() => {
+          this.pendingTribunals.delete(proposalId);
+          if (policy.onTimeout === "approve") {
+            resolve({
+              kind: "approved",
+              approvedScope: proposal.intent.scopeProposal ?? null
+            });
+            return;
+          }
+          reject(
+            new Error(
+              `Tribunal decision timed out after ${policy.timeout}ms for proposal '${proposalId}'`
+            )
+          );
+        }, policy.timeout);
+      }
+      this.pendingTribunals.set(proposalId, state);
+      this.notificationCallback?.(
+        proposalId,
+        proposal,
+        policy.members
+      );
+    });
+  }
+  submitVote(proposalId, voter, decision, reasoning) {
+    const state = this.pendingTribunals.get(proposalId);
+    if (!state) {
+      throw new Error(`No pending tribunal for proposal ${proposalId}`);
+    }
+    if (state.votes.has(voter.actorId)) {
+      throw new Error(`Actor ${voter.actorId} already voted on proposal ${proposalId}`);
+    }
+    const member = state.binding.policy.mode === "tribunal" ? state.binding.policy.members.some(({ actorId }) => actorId === voter.actorId) : false;
+    if (!member) {
+      throw new Error(`Actor ${voter.actorId} is not a tribunal member for proposal ${proposalId}`);
+    }
+    state.votes.set(voter.actorId, {
+      voter,
+      decision,
+      reasoning,
+      votedAt: Date.now()
+    });
+    this.checkQuorum(state);
+  }
+  isPending(proposalId) {
+    return this.pendingTribunals.has(proposalId);
+  }
+  getVotes(proposalId) {
+    const state = this.pendingTribunals.get(proposalId);
+    return state ? [...state.votes.values()] : [];
+  }
+  getPendingIds() {
+    return [...this.pendingTribunals.keys()];
+  }
+  clearAllPending() {
+    for (const [proposalId, state] of this.pendingTribunals) {
+      if (state.timeoutId) {
+        clearTimeout(state.timeoutId);
+      }
+      state.reject(new Error(`Tribunal handler cleared pending proposal ${proposalId}`));
+    }
+    this.pendingTribunals.clear();
+  }
+  checkQuorum(state) {
+    const policy = state.binding.policy;
+    if (policy.mode !== "tribunal") {
+      return;
+    }
+    const memberCount = policy.members.length;
+    let approveCount = 0;
+    let rejectCount = 0;
+    for (const vote of state.votes.values()) {
+      if (vote.decision === "approve") {
+        approveCount++;
+      } else if (vote.decision === "reject") {
+        rejectCount++;
+      }
+    }
+    let isComplete = false;
+    let isApproved = false;
+    switch (policy.quorum.kind) {
+      case "unanimous":
+        if (approveCount === memberCount) {
+          isComplete = true;
+          isApproved = true;
+        } else if (rejectCount > 0 || state.votes.size === memberCount) {
+          isComplete = true;
+        }
+        break;
+      case "majority": {
+        const majorityNeeded = Math.floor(memberCount / 2) + 1;
+        if (approveCount >= majorityNeeded) {
+          isComplete = true;
+          isApproved = true;
+        } else if (rejectCount >= majorityNeeded) {
+          isComplete = true;
+        } else if (state.votes.size === memberCount) {
+          isComplete = true;
+          isApproved = approveCount > rejectCount;
+        }
+        break;
+      }
+      case "threshold":
+        if (approveCount >= policy.quorum.count) {
+          isComplete = true;
+          isApproved = true;
+        } else if (rejectCount > memberCount - policy.quorum.count) {
+          isComplete = true;
+        } else if (state.votes.size === memberCount) {
+          isComplete = true;
+          isApproved = approveCount >= policy.quorum.count;
+        }
+        break;
+    }
+    if (!isComplete) {
+      return;
+    }
+    if (state.timeoutId) {
+      clearTimeout(state.timeoutId);
+    }
+    this.pendingTribunals.delete(state.proposalId);
+    if (isApproved) {
+      state.resolve({
+        kind: "approved",
+        approvedScope: state.proposal.intent.scopeProposal ?? null
+      });
+      return;
+    }
+    state.resolve({
+      kind: "rejected",
+      reason: `Tribunal rejected (${approveCount}/${memberCount} approved)`
+    });
+  }
+};
+function createTribunalHandler() {
+  return new TribunalHandler();
+}
+
+// src/authority/evaluator.ts
+var POLICY_MODE_TO_KIND = {
+  auto_approve: "auto",
+  hitl: "human",
+  policy_rules: "policy",
+  tribunal: "tribunal"
+};
+var AuthorityEvaluator = class {
+  handlers = /* @__PURE__ */ new Map();
+  autoHandler;
+  policyHandler;
+  hitlHandler;
+  tribunalHandler;
+  constructor() {
+    this.autoHandler = createAutoApproveHandler();
+    this.policyHandler = createPolicyRulesHandler();
+    this.hitlHandler = createHITLHandler();
+    this.tribunalHandler = createTribunalHandler();
+    this.handlers.set("auto_approve", this.autoHandler);
+    this.handlers.set("hitl", this.hitlHandler);
+    this.handlers.set("policy_rules", this.policyHandler);
+    this.handlers.set("tribunal", this.tribunalHandler);
+  }
+  async evaluate(proposal, binding) {
+    const handler = this.handlers.get(binding.policy.mode);
+    if (!handler) {
+      throw new Error(`Unknown policy mode: ${binding.policy.mode}`);
+    }
+    return handler.evaluate(proposal, binding);
+  }
+  registerHandler(policyMode, handler) {
+    this.handlers.set(policyMode, handler);
+  }
+  getAutoHandler() {
+    return this.autoHandler;
+  }
+  getPolicyHandler() {
+    return this.policyHandler;
+  }
+  getHITLHandler() {
+    return this.hitlHandler;
+  }
+  getTribunalHandler() {
+    return this.tribunalHandler;
+  }
+  getAuthorityKind(policyMode) {
+    return POLICY_MODE_TO_KIND[policyMode] ?? null;
+  }
+  submitHITLDecision(proposalId, decision, reasoning, approvedScope) {
+    this.hitlHandler.submitDecision(proposalId, decision, reasoning, approvedScope);
+  }
+  submitTribunalVote(proposalId, voter, decision, reasoning) {
+    this.tribunalHandler.submitVote(proposalId, voter, decision, reasoning);
+  }
+  hasPendingHITL() {
+    return this.hitlHandler.getPendingIds().length > 0;
+  }
+  hasPendingTribunal() {
+    return this.tribunalHandler.getPendingIds().length > 0;
+  }
+  getPendingHITLIds() {
+    return this.hitlHandler.getPendingIds();
+  }
+  getPendingTribunalIds() {
+    return this.tribunalHandler.getPendingIds();
+  }
+  clearAllPending() {
+    this.hitlHandler.clearAllPending();
+    this.tribunalHandler.clearAllPending();
+  }
+};
+function createAuthorityEvaluator() {
+  return new AuthorityEvaluator();
+}
+
+// src/event-dispatcher.ts
+function createGovernanceEventDispatcher(options) {
+  const sink = options.sink ?? createNoopGovernanceEventSink();
+  const now = options.now ?? Date.now;
+  return {
+    emitSealCompleted(governanceCommit, lineageCommit) {
+      const timestamp = now();
+      const outcome = governanceCommit.proposal.status === "completed" ? "completed" : "failed";
+      sink.emit(
+        options.service.createWorldCreatedEvent(
+          lineageCommit.world,
+          governanceCommit.proposal.proposalId,
+          deriveWorldCreatedFrom(governanceCommit, lineageCommit),
+          outcome,
+          timestamp
+        )
+      );
+      if (isTrueForkCommit(lineageCommit)) {
+        sink.emit(
+          options.service.createWorldForkedEvent(
+            governanceCommit.proposal.branchId,
+            lineageCommit.edge.from,
+            timestamp
+          )
+        );
+      }
+      if (outcome === "completed") {
+        sink.emit(options.service.createExecutionCompletedEvent(governanceCommit.proposal, timestamp));
+        return;
+      }
+      sink.emit(
+        options.service.createExecutionFailedEvent(
+          governanceCommit.proposal,
+          deriveExecutionFailure(lineageCommit),
+          timestamp
+        )
+      );
+    }
+  };
+}
+function deriveWorldCreatedFrom(governanceCommit, lineageCommit) {
+  if (lineageCommit.kind === "next") {
+    return lineageCommit.edge.from;
+  }
+  return lineageCommit.world.parentWorldId ?? governanceCommit.proposal.baseWorld;
+}
+function deriveExecutionFailure(lineageCommit) {
+  const currentError = lineageCommit.terminalSnapshot.system.lastError ?? void 0;
+  const pendingRequirements = lineageCommit.terminalSnapshot.system.pendingRequirements.map(
+    (requirement) => requirement.id
+  );
+  return {
+    summary: summarizeFailure(currentError ? 1 : 0, pendingRequirements.length),
+    ...currentError ? { currentError } : {},
+    ...pendingRequirements.length > 0 ? { pendingRequirements } : {}
+  };
+}
+function isTrueForkCommit(lineageCommit) {
+  return lineageCommit.kind === "next" && "forkCreated" in lineageCommit && lineageCommit.forkCreated === true;
+}
+function summarizeFailure(errorCount, pendingRequirementCount) {
+  if (errorCount > 0 && pendingRequirementCount > 0) {
+    return `Execution failed with ${errorCount} error(s) and ${pendingRequirementCount} pending requirement(s)`;
+  }
+  if (errorCount > 0) {
+    return `Execution failed with ${errorCount} error(s)`;
+  }
+  if (pendingRequirementCount > 0) {
+    return `Execution failed with ${pendingRequirementCount} pending requirement(s)`;
+  }
+  return "Execution failed";
+}
+
+// src/intent-instance.ts
+import { sha256, toJcs } from "@manifesto-ai/core";
+async function computeIntentKey(schemaHash, body) {
+  const input = [
+    schemaHash,
+    body.type,
+    toJcs(body.input ?? null),
+    toJcs(body.scopeProposal ?? null)
+  ].join(":");
+  return sha256(input);
+}
+async function createIntentInstance(options) {
+  const intentId = options.intentId ?? `intent-${crypto.randomUUID()}`;
+  const intentKey = await computeIntentKey(options.schemaHash, options.body);
+  return createIntentInstanceSync(
+    options.body,
+    intentId,
+    intentKey,
+    {
+      projectionId: options.projectionId,
+      source: options.source,
+      actor: options.actor,
+      note: options.note
+    }
+  );
+}
+function createIntentInstanceSync(body, intentId, intentKey, origin) {
+  return deepFreeze({
+    body,
+    intentId,
+    intentKey,
+    meta: {
+      origin
+    }
+  });
+}
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  for (const key of Object.getOwnPropertyNames(value)) {
+    const nested = value[key];
+    if (nested !== null && typeof nested === "object") {
+      deepFreeze(nested);
+    }
+  }
+  return Object.freeze(value);
+}
+
+// src/service/governance-service.ts
+function freeze(value) {
+  return Object.freeze(value);
+}
+var DefaultGovernanceService = class {
+  constructor(store, options = {}) {
+    this.store = store;
+    this.options = options;
+  }
+  createProposal(input) {
+    return freeze({
+      proposalId: input.proposalId ?? createProposalId(),
+      baseWorld: input.baseWorld,
+      branchId: input.branchId,
+      actorId: input.actorId,
+      authorityId: input.authorityId,
+      intent: freeze({ ...input.intent }),
+      status: "submitted",
+      executionKey: input.executionKey,
+      submittedAt: input.submittedAt,
+      epoch: input.epoch
+    });
+  }
+  beginEvaluating(proposal) {
+    return this.transitionProposal(proposal, "evaluating");
+  }
+  beginExecution(proposal) {
+    if (!proposal.decisionId) {
+      throw new Error(
+        "GOV-EXEC-1 violation: approved proposal requires decisionId before execution can begin"
+      );
+    }
+    return this.transitionProposal(proposal, "executing");
+  }
+  failExecution(proposal, completedAt, resultWorld) {
+    return this.transitionProposal(proposal, "failed", {
+      completedAt,
+      ...resultWorld !== void 0 ? { resultWorld } : {}
+    });
+  }
+  async prepareAuthorityResult(proposal, response, options) {
+    if (proposal.status !== "submitted" && proposal.status !== "evaluating") {
+      throw new Error(
+        `GOV-TRANS-1 violation: authority result requires ingress proposal, received ${proposal.status}`
+      );
+    }
+    const branchInfo = await this.resolveBranchInfo(proposal.branchId);
+    const currentEpoch = options.currentEpoch ?? branchInfo?.epoch ?? proposal.epoch;
+    const currentHead = options.currentBranchHead ?? branchInfo?.head ?? proposal.baseWorld;
+    if (this.shouldDiscardAuthorityResult(proposal, currentEpoch)) {
+      return {
+        proposal: this.prepareSupersede(proposal, "head_advance"),
+        discarded: true
+      };
+    }
+    if (response.kind === "approved") {
+      await this.assertBranchGateAvailable(proposal);
+      if (currentHead !== proposal.baseWorld) {
+        return {
+          proposal: this.prepareSupersede(proposal, "head_advance"),
+          discarded: true
+        };
+      }
+      const decisionRecord2 = freeze({
+        decisionId: options.decisionId ?? createDecisionId(),
+        proposalId: proposal.proposalId,
+        authorityId: proposal.authorityId,
+        decision: freeze({ kind: "approved" }),
+        decidedAt: options.decidedAt
+      });
+      return {
+        proposal: this.transitionProposal(proposal, "approved", {
+          decisionId: decisionRecord2.decisionId,
+          decidedAt: decisionRecord2.decidedAt,
+          approvedScope: response.approvedScope
+        }),
+        decisionRecord: decisionRecord2,
+        discarded: false
+      };
+    }
+    const decisionRecord = freeze({
+      decisionId: options.decisionId ?? createDecisionId(),
+      proposalId: proposal.proposalId,
+      authorityId: proposal.authorityId,
+      decision: freeze({
+        kind: "rejected",
+        ...response.reason ? { reason: response.reason } : {}
+      }),
+      decidedAt: options.decidedAt
+    });
+    return {
+      proposal: this.transitionProposal(proposal, "rejected", {
+        decisionId: decisionRecord.decisionId,
+        decidedAt: decisionRecord.decidedAt
+      }),
+      decisionRecord,
+      discarded: false
+    };
+  }
+  prepareSupersede(proposal, reason) {
+    return this.transitionProposal(proposal, "superseded", {
+      supersededReason: reason
+    });
+  }
+  async invalidateStaleIngress(branchId, currentEpoch) {
+    const branchInfo = await this.resolveBranchInfo(branchId);
+    const nextEpoch = currentEpoch ?? branchInfo?.epoch;
+    if (nextEpoch == null) {
+      throw new Error(`Cannot invalidate stale ingress without branch epoch for ${branchId}`);
+    }
+    return (await this.store.getProposalsByBranch(branchId)).filter((proposal) => isIngressStatus(proposal.status) && proposal.epoch < nextEpoch).map((proposal) => this.prepareSupersede(proposal, "head_advance"));
+  }
+  shouldDiscardAuthorityResult(proposal, currentEpoch) {
+    return proposal.epoch < currentEpoch;
+  }
+  deriveOutcome(terminalSnapshot) {
+    if (terminalSnapshot.system.lastError != null) {
+      return "failed";
+    }
+    if (terminalSnapshot.system.pendingRequirements.length > 0) {
+      return "failed";
+    }
+    return "completed";
+  }
+  async finalize(executingProposal, lineageCommit, completedAt) {
+    if (executingProposal.status !== "executing") {
+      throw new Error(
+        `GOV-SEAL-6 violation: finalize() requires executing proposal, received ${executingProposal.status}`
+      );
+    }
+    if (!executingProposal.decisionId) {
+      throw new Error("GOV-SEAL-6 violation: executing proposal is missing decisionId");
+    }
+    const decisionRecord = await this.store.getDecisionRecord(executingProposal.decisionId);
+    if (!decisionRecord) {
+      throw new Error(
+        `GOV-SEAL-6 violation: decision record ${executingProposal.decisionId} not found`
+      );
+    }
+    const derivedOutcome = this.deriveOutcome(lineageCommit.terminalSnapshot);
+    if (derivedOutcome !== lineageCommit.terminalStatus) {
+      throw new Error(
+        `GOV-SEAL-1 violation: deriveOutcome=${derivedOutcome} but lineageCommit.terminalStatus=${lineageCommit.terminalStatus}`
+      );
+    }
+    const proposal = this.transitionProposal(executingProposal, derivedOutcome, {
+      resultWorld: lineageCommit.worldId,
+      completedAt
+    });
+    return freeze({
+      proposal,
+      decisionRecord
+    });
+  }
+  createProposalSubmittedEvent(proposal, timestamp = Date.now()) {
+    return freeze({
+      type: "proposal:submitted",
+      timestamp,
+      proposalId: proposal.proposalId,
+      actorId: proposal.actorId,
+      baseWorld: proposal.baseWorld,
+      branchId: proposal.branchId,
+      intent: freeze({
+        type: proposal.intent.type,
+        intentId: proposal.intent.intentId,
+        ...proposal.intent.input !== void 0 ? { input: proposal.intent.input } : {}
+      }),
+      executionKey: proposal.executionKey,
+      epoch: proposal.epoch
+    });
+  }
+  createProposalEvaluatingEvent(proposal, timestamp = Date.now()) {
+    return freeze({
+      type: "proposal:evaluating",
+      timestamp,
+      proposalId: proposal.proposalId
+    });
+  }
+  createProposalDecidedEvent(proposal, decisionRecord, timestamp = Date.now()) {
+    return freeze({
+      type: "proposal:decided",
+      timestamp,
+      proposalId: proposal.proposalId,
+      decisionId: decisionRecord.decisionId,
+      decision: decisionRecord.decision.kind,
+      ...decisionRecord.decision.kind === "rejected" && decisionRecord.decision.reason ? { reason: decisionRecord.decision.reason } : {}
+    });
+  }
+  createProposalSupersededEvent(proposal, currentEpoch, timestamp = Date.now()) {
+    if (proposal.status !== "superseded" || !proposal.supersededReason) {
+      throw new Error(
+        "GOV-EPOCH-5 violation: superseded event requires proposal.status='superseded' with supersededReason"
+      );
+    }
+    return freeze({
+      type: "proposal:superseded",
+      timestamp,
+      proposalId: proposal.proposalId,
+      currentEpoch,
+      proposalEpoch: proposal.epoch,
+      reason: proposal.supersededReason
+    });
+  }
+  createExecutionCompletedEvent(proposal, timestamp = Date.now()) {
+    if (!proposal.resultWorld) {
+      throw new Error(
+        "GOV-EVT-6 violation: execution:completed requires proposal.resultWorld"
+      );
+    }
+    return freeze({
+      type: "execution:completed",
+      timestamp,
+      proposalId: proposal.proposalId,
+      executionKey: proposal.executionKey,
+      resultWorld: proposal.resultWorld
+    });
+  }
+  createExecutionFailedEvent(proposal, error, timestamp = Date.now()) {
+    if (!proposal.resultWorld) {
+      throw new Error(
+        "GOV-EVT-7 violation: execution:failed requires proposal.resultWorld"
+      );
+    }
+    return freeze({
+      type: "execution:failed",
+      timestamp,
+      proposalId: proposal.proposalId,
+      executionKey: proposal.executionKey,
+      resultWorld: proposal.resultWorld,
+      error: freeze({
+        summary: error.summary,
+        ...error.currentError !== void 0 ? { currentError: error.currentError } : {},
+        ...error.pendingRequirements !== void 0 ? { pendingRequirements: error.pendingRequirements } : {}
+      })
+    });
+  }
+  createWorldCreatedEvent(world, proposalId, from, outcome, timestamp = Date.now()) {
+    return freeze({
+      type: "world:created",
+      timestamp,
+      world,
+      from,
+      proposalId,
+      outcome
+    });
+  }
+  createWorldForkedEvent(branchId, forkPoint, timestamp = Date.now()) {
+    return freeze({
+      type: "world:forked",
+      timestamp,
+      branchId,
+      forkPoint
+    });
+  }
+  async resolveBranchInfo(branchId) {
+    return this.options.lineageService?.getBranch(branchId) ?? null;
+  }
+  async assertBranchGateAvailable(proposal) {
+    const occupant = await this.store.getExecutionStageProposal(proposal.branchId);
+    if (occupant && occupant.proposalId !== proposal.proposalId) {
+      throw new Error(
+        `GOV-BRANCH-GATE-1 violation: branch ${proposal.branchId} already occupied by ${occupant.proposalId}`
+      );
+    }
+  }
+  transitionProposal(proposal, to, updates = {}) {
+    if (!isValidTransition(proposal.status, to)) {
+      throw new Error(
+        `GOV-TRANS-1 violation: invalid transition ${proposal.status} -> ${to}; valid targets are ${getValidTransitions(proposal.status).join(", ")}`
+      );
+    }
+    if (to === "superseded") {
+      if (updates.decisionId != null) {
+        throw new Error("GOV-TRANS-3 violation: superseded transition must not create DecisionRecord");
+      }
+      if (!updates.supersededReason) {
+        throw new Error("GOV-STAGE-7 violation: superseded proposal must record supersededReason");
+      }
+    }
+    if (transitionCreatesDecisionRecord(proposal.status, to) && updates.decisionId == null) {
+      throw new Error(
+        `GOV-TRANS-2 violation: transition ${proposal.status} -> ${to} requires decisionId`
+      );
+    }
+    if (to !== "superseded" && updates.supersededReason != null) {
+      throw new Error("GOV-TRANS-4 violation: supersededReason is only valid on superseded proposals");
+    }
+    if (isExecutionStageStatus(proposal.status) && to === "superseded") {
+      throw new Error("GOV-STAGE-4 violation: execution-stage proposals must not be superseded");
+    }
+    return freeze({
+      ...proposal,
+      status: to,
+      ...updates.decisionId !== void 0 ? { decisionId: updates.decisionId } : {},
+      ...updates.decidedAt !== void 0 ? { decidedAt: updates.decidedAt } : {},
+      ...updates.completedAt !== void 0 ? { completedAt: updates.completedAt } : {},
+      ...updates.resultWorld !== void 0 ? { resultWorld: updates.resultWorld } : {},
+      ...updates.approvedScope !== void 0 ? { approvedScope: updates.approvedScope } : {},
+      ...updates.supersededReason !== void 0 ? { supersededReason: updates.supersededReason } : {},
+      ...to !== "superseded" ? { supersededReason: void 0 } : {}
+    });
+  }
+};
+function createGovernanceService(store, options) {
+  return new DefaultGovernanceService(store, options);
+}
+
+export {
+  createProposalId,
+  createDecisionId,
+  createExecutionKey,
+  defaultExecutionKeyPolicy,
+  createNoopGovernanceEventSink,
+  toHostIntent,
+  INGRESS_STATUSES,
+  EXECUTION_STAGE_STATUSES,
+  TERMINAL_STATUSES,
+  DECISION_TRANSITION_TARGETS,
+  isIngressStatus,
+  isExecutionStageStatus,
+  isTerminalStatus,
+  isValidTransition,
+  getValidTransitions,
+  transitionCreatesDecisionRecord,
+  InMemoryGovernanceStore,
+  createInMemoryGovernanceStore,
+  AutoApproveHandler,
+  createAutoApproveHandler,
+  HITLHandler,
+  createHITLHandler,
+  PolicyRulesHandler,
+  createPolicyRulesHandler,
+  TribunalHandler,
+  createTribunalHandler,
+  AuthorityEvaluator,
+  createAuthorityEvaluator,
+  createGovernanceEventDispatcher,
+  computeIntentKey,
+  createIntentInstance,
+  createIntentInstanceSync,
+  DefaultGovernanceService,
+  createGovernanceService
+};
+//# sourceMappingURL=chunk-JLXJCLOD.js.map