@manifesto-ai/governance 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Manifesto AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# @manifesto-ai/governance
+
+> Split-native governance protocol for legitimacy, authority, and proposal lifecycle.
+
+`@manifesto-ai/governance` is the package to use when you need to reason about proposal legitimacy directly. It owns the governance lifecycle and composes with `@manifesto-ai/lineage` when you need branch-aware sealing.
+
+> **Current Contract Note:** The current public package contract is documented in [docs/governance-SPEC-2.0.0v.md](docs/governance-SPEC-2.0.0v.md). The v1.0.0 governance spec remains available as the historical split-era baseline.
+
+## What This Package Owns
+
+- proposal lifecycle and status changes
+- actor and authority binding
+- execution-key policy and context
+- governance events and event dispatch
+- in-memory governance storage
+- intent-instance helpers
+
+## When to Use It
+
+Use `@manifesto-ai/governance` directly when you want:
+
+- custom governance evaluation or policy logic
+- isolated tests for proposal lifecycle behavior
+- explicit control over authority and event dispatch
+- a lower-level building block for `@manifesto-ai/world`
+
+## Quick Start
+
+```typescript
+import {
+  createGovernanceEventDispatcher,
+  createGovernanceService,
+  createInMemoryGovernanceStore,
+} from "@manifesto-ai/governance";
+import { createLineageService, createInMemoryLineageStore } from "@manifesto-ai/lineage";
+
+const lineageStore = createInMemoryLineageStore();
+const lineage = createLineageService(lineageStore);
+const governanceStore = createInMemoryGovernanceStore();
+const governance = createGovernanceService(governanceStore, {
+  lineageService: lineage,
+});
+const eventDispatcher = createGovernanceEventDispatcher({ service: governance });
+```
+
+## Docs
+
+- [Docs Landing](docs/README.md)
+- [Governance Guide](docs/GUIDE.md)
+- [Governance Specification](docs/governance-SPEC-2.0.0v.md)
+- [Historical v1 Baseline](docs/governance-SPEC-1.0.0v.md)
+- [VERSION-INDEX](docs/VERSION-INDEX.md)

package/dist/index.d.ts

@@ -0,0 +1,472 @@
+import { ErrorValue, Intent as Intent$1, Snapshot } from '@manifesto-ai/core';
+export { Snapshot } from '@manifesto-ai/core';
+import { WorldId, BranchId, World, PreparedLineageCommit, LineageService } from '@manifesto-ai/lineage';
+export { ArtifactRef, BranchId, PreparedLineageCommit, World, WorldId } from '@manifesto-ai/lineage';
+
+type ProposalId = string;
+type DecisionId = string;
+type ActorId = string;
+type AuthorityId = string;
+type ExecutionKey = string;
+type ActorKind = "human" | "agent" | "system";
+type AuthorityKind = "auto" | "human" | "policy" | "tribunal";
+type ProposalStatus = "submitted" | "evaluating" | "approved" | "rejected" | "executing" | "completed" | "failed" | "superseded";
+type SupersedeReason = "branch_switch" | "head_advance" | "manual_cancel";
+interface ActorRef {
+    readonly actorId: ActorId;
+    readonly kind: ActorKind;
+    readonly name?: string;
+    readonly meta?: Record<string, unknown>;
+}
+interface AuthorityRef {
+    readonly authorityId: AuthorityId;
+    readonly kind: AuthorityKind;
+    readonly name?: string;
+}
+interface IntentScope {
+    readonly allowedPaths?: readonly string[];
+    readonly note?: string;
+}
+type SourceKind = "ui" | "api" | "agent" | "system";
+interface SourceRef {
+    readonly kind: SourceKind;
+    readonly eventId: string;
+}
+interface IntentOrigin {
+    readonly projectionId: string;
+    readonly source: SourceRef;
+    readonly actor: ActorRef;
+    readonly note?: string;
+}
+interface IntentBody {
+    readonly type: string;
+    readonly input?: unknown;
+    readonly scopeProposal?: IntentScope;
+}
+interface IntentInstance {
+    readonly body: IntentBody;
+    readonly intentId: string;
+    readonly intentKey: string;
+    readonly meta: {
+        readonly origin: IntentOrigin;
+    };
+}
+interface Intent {
+    readonly type: string;
+    readonly intentId: string;
+    readonly input?: unknown;
+    readonly scopeProposal?: IntentScope;
+}
+interface ExecutionKeyContext {
+    readonly proposalId: ProposalId;
+    readonly actorId: ActorId;
+    readonly baseWorld: WorldId;
+    readonly branchId: BranchId;
+    readonly attempt: number;
+}
+type ExecutionKeyPolicy = (context: ExecutionKeyContext) => ExecutionKey;
+interface Proposal {
+    readonly proposalId: ProposalId;
+    readonly baseWorld: WorldId;
+    readonly branchId: BranchId;
+    readonly actorId: ActorId;
+    readonly authorityId: AuthorityId;
+    readonly intent: Intent;
+    readonly status: ProposalStatus;
+    readonly executionKey: ExecutionKey;
+    readonly submittedAt: number;
+    readonly decidedAt?: number;
+    readonly completedAt?: number;
+    readonly decisionId?: DecisionId;
+    readonly epoch: number;
+    readonly resultWorld?: WorldId;
+    readonly supersededReason?: SupersedeReason;
+    readonly approvedScope?: unknown;
+}
+type FinalDecision = {
+    readonly kind: "approved";
+} | {
+    readonly kind: "rejected";
+    readonly reason?: string;
+};
+interface DecisionRecord {
+    readonly decisionId: DecisionId;
+    readonly proposalId: ProposalId;
+    readonly authorityId: AuthorityId;
+    readonly decision: FinalDecision;
+    readonly decidedAt: number;
+}
+type AuthorityPolicy = {
+    readonly mode: "auto_approve";
+    readonly reason?: string;
+} | {
+    readonly mode: "hitl";
+    readonly delegate: ActorRef;
+    readonly timeout?: number;
+    readonly onTimeout?: "approve" | "reject";
+} | {
+    readonly mode: "policy_rules";
+    readonly rules: readonly PolicyRule[];
+    readonly defaultDecision: "approve" | "reject" | "escalate";
+    readonly escalateTo?: AuthorityRef;
+} | {
+    readonly mode: "tribunal";
+    readonly members: readonly ActorRef[];
+    readonly quorum: QuorumRule;
+    readonly timeout?: number;
+    readonly onTimeout?: "approve" | "reject";
+};
+interface ActorAuthorityBinding {
+    readonly actorId: ActorId;
+    readonly authorityId: AuthorityId;
+    readonly policy: AuthorityPolicy;
+}
+type PolicyCondition = {
+    readonly kind: "intent_type";
+    readonly types: readonly string[];
+} | {
+    readonly kind: "scope_pattern";
+    readonly pattern: string;
+} | {
+    readonly kind: "custom";
+    readonly evaluator: string;
+};
+interface PolicyRule {
+    readonly condition: PolicyCondition;
+    readonly decision: "approve" | "reject" | "escalate";
+    readonly reason?: string;
+}
+type QuorumRule = {
+    readonly kind: "unanimous";
+} | {
+    readonly kind: "majority";
+} | {
+    readonly kind: "threshold";
+    readonly count: number;
+};
+type WaitingFor = {
+    readonly kind: "human";
+    readonly delegate: ActorRef;
+} | {
+    readonly kind: "tribunal";
+    readonly members: readonly ActorRef[];
+} | {
+    readonly kind: "timeout";
+    readonly until: number;
+};
+type AuthorityResponse = {
+    readonly kind: "approved";
+    readonly approvedScope: IntentScope | null;
+} | {
+    readonly kind: "rejected";
+    readonly reason?: string;
+} | {
+    readonly kind: "pending";
+    readonly waitingFor: WaitingFor;
+};
+interface Vote {
+    readonly voter: ActorRef;
+    readonly decision: "approve" | "reject" | "abstain";
+    readonly reasoning?: string;
+    readonly votedAt: number;
+}
+type GovernanceEventType = "proposal:submitted" | "proposal:evaluating" | "proposal:decided" | "proposal:superseded" | "execution:completed" | "execution:failed" | "world:created" | "world:forked";
+interface BaseGovernanceEvent<T extends GovernanceEventType> {
+    readonly type: T;
+    readonly timestamp: number;
+}
+interface ErrorInfo {
+    readonly summary: string;
+    readonly currentError?: ErrorValue;
+    readonly pendingRequirements?: readonly string[];
+}
+interface ProposalSubmittedEvent extends BaseGovernanceEvent<"proposal:submitted"> {
+    readonly proposalId: ProposalId;
+    readonly actorId: ActorId;
+    readonly baseWorld: WorldId;
+    readonly branchId: BranchId;
+    readonly intent: {
+        readonly type: string;
+        readonly intentId: string;
+        readonly input?: unknown;
+    };
+    readonly executionKey: ExecutionKey;
+    readonly epoch: number;
+}
+interface ProposalEvaluatingEvent extends BaseGovernanceEvent<"proposal:evaluating"> {
+    readonly proposalId: ProposalId;
+}
+interface ProposalDecidedEvent extends BaseGovernanceEvent<"proposal:decided"> {
+    readonly proposalId: ProposalId;
+    readonly decisionId: DecisionId;
+    readonly decision: "approved" | "rejected";
+    readonly reason?: string;
+}
+interface ProposalSupersededEvent extends BaseGovernanceEvent<"proposal:superseded"> {
+    readonly proposalId: ProposalId;
+    readonly currentEpoch: number;
+    readonly proposalEpoch: number;
+    readonly reason: SupersedeReason;
+}
+interface ExecutionCompletedEvent extends BaseGovernanceEvent<"execution:completed"> {
+    readonly proposalId: ProposalId;
+    readonly executionKey: ExecutionKey;
+    readonly resultWorld: WorldId;
+}
+interface ExecutionFailedEvent extends BaseGovernanceEvent<"execution:failed"> {
+    readonly proposalId: ProposalId;
+    readonly executionKey: ExecutionKey;
+    readonly resultWorld: WorldId;
+    readonly error: ErrorInfo;
+}
+interface WorldCreatedEvent extends BaseGovernanceEvent<"world:created"> {
+    readonly world: World;
+    readonly from: WorldId;
+    readonly proposalId: ProposalId;
+    readonly outcome: "completed" | "failed";
+}
+interface WorldForkedEvent extends BaseGovernanceEvent<"world:forked"> {
+    readonly branchId: BranchId;
+    readonly forkPoint: WorldId;
+}
+type GovernanceEvent = ProposalSubmittedEvent | ProposalEvaluatingEvent | ProposalDecidedEvent | ProposalSupersededEvent | ExecutionCompletedEvent | ExecutionFailedEvent | WorldCreatedEvent | WorldForkedEvent;
+interface GovernanceEventSink {
+    emit(event: GovernanceEvent): void;
+}
+interface GovernanceEventDispatcher {
+    emitSealCompleted(governanceCommit: PreparedGovernanceCommit, lineageCommit: PreparedLineageCommit): void;
+}
+interface PreparedGovernanceCommit {
+    readonly proposal: Proposal;
+    readonly decisionRecord: DecisionRecord;
+}
+interface GovernanceStore {
+    putProposal(proposal: Proposal): Promise<void>;
+    getProposal(proposalId: ProposalId): Promise<Proposal | null>;
+    getProposalsByBranch(branchId: BranchId): Promise<readonly Proposal[]>;
+    getExecutionStageProposal(branchId: BranchId): Promise<Proposal | null>;
+    putDecisionRecord(record: DecisionRecord): Promise<void>;
+    getDecisionRecord(decisionId: DecisionId): Promise<DecisionRecord | null>;
+    putActorBinding(binding: ActorAuthorityBinding): Promise<void>;
+    getActorBinding(actorId: ActorId): Promise<ActorAuthorityBinding | null>;
+    getActorBindings(): Promise<readonly ActorAuthorityBinding[]>;
+}
+interface CreateProposalInput {
+    readonly proposalId?: ProposalId;
+    readonly baseWorld: WorldId;
+    readonly branchId: BranchId;
+    readonly actorId: ActorId;
+    readonly authorityId: AuthorityId;
+    readonly intent: Intent;
+    readonly executionKey: ExecutionKey;
+    readonly submittedAt: number;
+    readonly epoch: number;
+}
+interface PrepareAuthorityResultOptions {
+    readonly currentEpoch?: number;
+    readonly currentBranchHead?: WorldId;
+    readonly decisionId?: DecisionId;
+    readonly decidedAt: number;
+}
+interface PreparedAuthorityResult {
+    readonly proposal: Proposal;
+    readonly decisionRecord?: DecisionRecord;
+    readonly discarded: boolean;
+}
+interface GovernanceService {
+    createProposal(input: CreateProposalInput): Proposal;
+    prepareAuthorityResult(proposal: Proposal, response: Extract<AuthorityResponse, {
+        kind: "approved" | "rejected";
+    }>, options: PrepareAuthorityResultOptions): Promise<PreparedAuthorityResult>;
+    prepareSupersede(proposal: Proposal, reason: SupersedeReason): Proposal;
+    invalidateStaleIngress(branchId: BranchId, currentEpoch?: number): Promise<readonly Proposal[]>;
+    shouldDiscardAuthorityResult(proposal: Proposal, currentEpoch: number): boolean;
+    deriveOutcome(terminalSnapshot: Snapshot): "completed" | "failed";
+    finalize(executingProposal: Proposal, lineageCommit: PreparedLineageCommit, completedAt: number): Promise<PreparedGovernanceCommit>;
+    createProposalSubmittedEvent(proposal: Proposal, timestamp?: number): ProposalSubmittedEvent;
+    createProposalEvaluatingEvent(proposal: Proposal, timestamp?: number): ProposalEvaluatingEvent;
+    createProposalDecidedEvent(proposal: Proposal, decisionRecord: DecisionRecord, timestamp?: number): ProposalDecidedEvent;
+    createProposalSupersededEvent(proposal: Proposal, currentEpoch: number, timestamp?: number): ProposalSupersededEvent;
+    createExecutionCompletedEvent(proposal: Proposal, timestamp?: number): ExecutionCompletedEvent;
+    createExecutionFailedEvent(proposal: Proposal, error: ErrorInfo, timestamp?: number): ExecutionFailedEvent;
+    createWorldCreatedEvent(world: World, proposalId: ProposalId, from: WorldId, outcome: "completed" | "failed", timestamp?: number): WorldCreatedEvent;
+    createWorldForkedEvent(branchId: BranchId, forkPoint: WorldId, timestamp?: number): WorldForkedEvent;
+}
+declare function createProposalId(value?: string): ProposalId;
+declare function createDecisionId(value?: string): DecisionId;
+declare function createExecutionKey(proposalId: ProposalId, attempt?: number): ExecutionKey;
+declare const defaultExecutionKeyPolicy: ExecutionKeyPolicy;
+declare function createNoopGovernanceEventSink(): GovernanceEventSink;
+declare function toHostIntent(intent: Intent | IntentInstance): Intent$1;
+
+interface CreateIntentInstanceOptions {
+    readonly body: IntentBody;
+    readonly schemaHash: string;
+    readonly projectionId: string;
+    readonly source: SourceRef;
+    readonly actor: ActorRef;
+    readonly note?: string;
+    readonly intentId?: string;
+}
+declare function computeIntentKey(schemaHash: string, body: IntentBody): Promise<string>;
+declare function createIntentInstance(options: CreateIntentInstanceOptions): Promise<IntentInstance>;
+declare function createIntentInstanceSync(body: IntentBody, intentId: string, intentKey: string, origin: IntentOrigin): IntentInstance;
+
+declare const INGRESS_STATUSES: readonly ["submitted", "evaluating"];
+declare const EXECUTION_STAGE_STATUSES: readonly ["approved", "executing"];
+declare const TERMINAL_STATUSES: readonly ["rejected", "completed", "failed", "superseded"];
+declare const DECISION_TRANSITION_TARGETS: readonly ["approved", "rejected"];
+declare function isIngressStatus(status: ProposalStatus): boolean;
+declare function isExecutionStageStatus(status: ProposalStatus): boolean;
+declare function isTerminalStatus(status: ProposalStatus): boolean;
+declare function isValidTransition(from: ProposalStatus, to: ProposalStatus): boolean;
+declare function getValidTransitions(status: ProposalStatus): ProposalStatus[];
+declare function transitionCreatesDecisionRecord(from: ProposalStatus, to: ProposalStatus): boolean;
+
+type InMemoryGovernanceStoreState = {
+    proposals: Map<ProposalId, Proposal>;
+    decisions: Map<DecisionId, DecisionRecord>;
+    actorBindings: Map<ActorId, ActorAuthorityBinding>;
+};
+declare class InMemoryGovernanceStore implements GovernanceStore {
+    private readonly proposals;
+    private readonly decisions;
+    private readonly actorBindings;
+    putProposal(proposal: Proposal): Promise<void>;
+    getProposal(proposalId: ProposalId): Promise<Proposal | null>;
+    getProposalsByBranch(branchId: BranchId): Promise<readonly Proposal[]>;
+    getExecutionStageProposal(branchId: BranchId): Promise<Proposal | null>;
+    putDecisionRecord(record: DecisionRecord): Promise<void>;
+    getDecisionRecord(decisionId: DecisionId): Promise<DecisionRecord | null>;
+    putActorBinding(binding: ActorAuthorityBinding): Promise<void>;
+    getActorBinding(actorId: ActorId): Promise<ActorAuthorityBinding | null>;
+    getActorBindings(): Promise<readonly ActorAuthorityBinding[]>;
+    snapshotState(): InMemoryGovernanceStoreState;
+    restoreState(state: InMemoryGovernanceStoreState): void;
+}
+declare function createInMemoryGovernanceStore(): InMemoryGovernanceStore;
+
+interface GovernanceServiceOptions {
+    readonly lineageService?: Pick<LineageService, "getBranch">;
+}
+declare class DefaultGovernanceService implements GovernanceService {
+    private readonly store;
+    private readonly options;
+    constructor(store: GovernanceStore, options?: GovernanceServiceOptions);
+    createProposal(input: CreateProposalInput): Proposal;
+    prepareAuthorityResult(proposal: Proposal, response: Extract<AuthorityResponse, {
+        kind: "approved" | "rejected";
+    }>, options: PrepareAuthorityResultOptions): Promise<PreparedAuthorityResult>;
+    prepareSupersede(proposal: Proposal, reason: SupersedeReason): Proposal;
+    invalidateStaleIngress(branchId: string, currentEpoch?: number): Promise<readonly Proposal[]>;
+    shouldDiscardAuthorityResult(proposal: Proposal, currentEpoch: number): boolean;
+    deriveOutcome(terminalSnapshot: Snapshot): "completed" | "failed";
+    finalize(executingProposal: Proposal, lineageCommit: PreparedLineageCommit, completedAt: number): Promise<PreparedGovernanceCommit>;
+    createProposalSubmittedEvent(proposal: Proposal, timestamp?: number): ProposalSubmittedEvent;
+    createProposalEvaluatingEvent(proposal: Proposal, timestamp?: number): ProposalEvaluatingEvent;
+    createProposalDecidedEvent(proposal: Proposal, decisionRecord: DecisionRecord, timestamp?: number): ProposalDecidedEvent;
+    createProposalSupersededEvent(proposal: Proposal, currentEpoch: number, timestamp?: number): ProposalSupersededEvent;
+    createExecutionCompletedEvent(proposal: Proposal, timestamp?: number): ExecutionCompletedEvent;
+    createExecutionFailedEvent(proposal: Proposal, error: ErrorInfo, timestamp?: number): ExecutionFailedEvent;
+    createWorldCreatedEvent(world: World, proposalId: ProposalId, from: WorldId, outcome: "completed" | "failed", timestamp?: number): WorldCreatedEvent;
+    createWorldForkedEvent(branchId: BranchId, forkPoint: WorldId, timestamp?: number): WorldForkedEvent;
+    private resolveBranchInfo;
+    private assertBranchGateAvailable;
+    private transitionProposal;
+}
+declare function createGovernanceService(store: GovernanceStore, options?: GovernanceServiceOptions): DefaultGovernanceService;
+
+interface CreateGovernanceEventDispatcherOptions {
+    readonly service: Pick<GovernanceService, "createExecutionCompletedEvent" | "createExecutionFailedEvent" | "createWorldCreatedEvent" | "createWorldForkedEvent">;
+    readonly sink?: GovernanceEventSink;
+    readonly now?: () => number;
+}
+declare function createGovernanceEventDispatcher(options: CreateGovernanceEventDispatcherOptions): GovernanceEventDispatcher;
+
+interface AuthorityHandler {
+    evaluate(proposal: Proposal, binding: ActorAuthorityBinding): Promise<AuthorityResponse>;
+}
+interface HITLDecisionCallback {
+    (proposalId: string, decision: "approved" | "rejected", reasoning?: string): void;
+}
+interface HITLPendingState {
+    proposalId: string;
+    proposal?: Proposal;
+    resolve: (response: AuthorityResponse) => void;
+    reject: (error: Error) => void;
+    timeoutId?: ReturnType<typeof setTimeout>;
+}
+
+declare class AutoApproveHandler implements AuthorityHandler {
+    evaluate(proposal: Proposal, binding: ActorAuthorityBinding): Promise<AuthorityResponse>;
+}
+declare function createAutoApproveHandler(): AutoApproveHandler;
+
+type CustomConditionEvaluator = (proposal: Proposal, binding: ActorAuthorityBinding) => boolean;
+declare class PolicyRulesHandler implements AuthorityHandler {
+    private readonly customEvaluators;
+    registerCustomEvaluator(name: string, evaluator: CustomConditionEvaluator): void;
+    evaluate(proposal: Proposal, binding: ActorAuthorityBinding): Promise<AuthorityResponse>;
+    private evaluateCondition;
+    private matchPattern;
+    private applyDecision;
+}
+declare function createPolicyRulesHandler(): PolicyRulesHandler;
+
+type HITLNotificationCallback = (proposalId: string, proposal: Proposal, binding: ActorAuthorityBinding) => void;
+declare class HITLHandler implements AuthorityHandler {
+    private readonly pendingDecisions;
+    private readonly notificationCallbacks;
+    onPendingDecision(callback: HITLNotificationCallback): () => void;
+    evaluate(proposal: Proposal, binding: ActorAuthorityBinding): Promise<AuthorityResponse>;
+    submitDecision(proposalId: string, decision: "approved" | "rejected", reasoning?: string, approvedScope?: IntentScope | null): void;
+    isPending(proposalId: string): boolean;
+    getPendingIds(): string[];
+    clearAllPending(): void;
+}
+declare function createHITLHandler(): HITLHandler;
+
+type TribunalNotificationCallback = (proposalId: string, proposal: Proposal, members: readonly ActorRef[]) => void;
+declare class TribunalHandler implements AuthorityHandler {
+    private readonly pendingTribunals;
+    private notificationCallback?;
+    onPendingTribunal(callback: TribunalNotificationCallback): void;
+    evaluate(proposal: Proposal, binding: ActorAuthorityBinding): Promise<AuthorityResponse>;
+    submitVote(proposalId: string, voter: ActorRef, decision: "approve" | "reject" | "abstain", reasoning?: string): void;
+    isPending(proposalId: string): boolean;
+    getVotes(proposalId: string): Vote[];
+    getPendingIds(): string[];
+    clearAllPending(): void;
+    private checkQuorum;
+}
+declare function createTribunalHandler(): TribunalHandler;
+
+declare class AuthorityEvaluator {
+    private readonly handlers;
+    private readonly autoHandler;
+    private readonly policyHandler;
+    private readonly hitlHandler;
+    private readonly tribunalHandler;
+    constructor();
+    evaluate(proposal: Proposal, binding: ActorAuthorityBinding): Promise<AuthorityResponse>;
+    registerHandler(policyMode: string, handler: AuthorityHandler): void;
+    getAutoHandler(): AutoApproveHandler;
+    getPolicyHandler(): PolicyRulesHandler;
+    getHITLHandler(): HITLHandler;
+    getTribunalHandler(): TribunalHandler;
+    getAuthorityKind(policyMode: string): AuthorityKind | null;
+    submitHITLDecision(proposalId: string, decision: "approved" | "rejected", reasoning?: string, approvedScope?: IntentScope | null): void;
+    submitTribunalVote(proposalId: string, voter: {
+        actorId: string;
+        kind: "human" | "agent" | "system";
+        name?: string;
+    }, decision: "approve" | "reject" | "abstain", reasoning?: string): void;
+    hasPendingHITL(): boolean;
+    hasPendingTribunal(): boolean;
+    getPendingHITLIds(): string[];
+    getPendingTribunalIds(): string[];
+    clearAllPending(): void;
+}
+declare function createAuthorityEvaluator(): AuthorityEvaluator;
+
+export { type ActorAuthorityBinding, type ActorId, type ActorKind, type ActorRef, AuthorityEvaluator, type AuthorityHandler, type AuthorityId, type AuthorityKind, type AuthorityPolicy, type AuthorityRef, type AuthorityResponse, AutoApproveHandler, type BaseGovernanceEvent, type CreateGovernanceEventDispatcherOptions, type CreateIntentInstanceOptions, type CreateProposalInput, type CustomConditionEvaluator, DECISION_TRANSITION_TARGETS, type DecisionId, type DecisionRecord, DefaultGovernanceService, EXECUTION_STAGE_STATUSES, type ErrorInfo, type ExecutionCompletedEvent, type ExecutionFailedEvent, type ExecutionKey, type ExecutionKeyContext, type ExecutionKeyPolicy, type FinalDecision, type GovernanceEvent, type GovernanceEventDispatcher, type GovernanceEventSink, type GovernanceEventType, type GovernanceService, type GovernanceStore, type HITLDecisionCallback, HITLHandler, type HITLNotificationCallback, type HITLPendingState, INGRESS_STATUSES, InMemoryGovernanceStore, type Intent, type IntentBody, type IntentInstance, type IntentOrigin, type IntentScope, type PolicyCondition, type PolicyRule, PolicyRulesHandler, type PrepareAuthorityResultOptions, type PreparedAuthorityResult, type PreparedGovernanceCommit, type Proposal, type ProposalDecidedEvent, type ProposalEvaluatingEvent, type ProposalId, type ProposalStatus, type ProposalSubmittedEvent, type ProposalSupersededEvent, type QuorumRule, type SourceKind, type SourceRef, type SupersedeReason, TERMINAL_STATUSES, TribunalHandler, type TribunalNotificationCallback, type Vote, type WaitingFor, type WorldCreatedEvent, type WorldForkedEvent, computeIntentKey, createAuthorityEvaluator, createAutoApproveHandler, createDecisionId, createExecutionKey, createGovernanceEventDispatcher, createGovernanceService, createHITLHandler, createInMemoryGovernanceStore, createIntentInstance, createIntentInstanceSync, createNoopGovernanceEventSink, createPolicyRulesHandler, createProposalId, createTribunalHandler, defaultExecutionKeyPolicy, getValidTransitions, isExecutionStageStatus, isIngressStatus, isTerminalStatus, isValidTransition, toHostIntent, transitionCreatesDecisionRecord };