@manifesto-ai/governance 3.1.0 → 3.1.2

package/README.md

@@ -10,12 +10,14 @@
 
 ```ts
 import { createManifesto } from "@manifesto-ai/sdk";
+import { createInMemoryLineageStore, withLineage } from "@manifesto-ai/lineage";
 import { withGovernance } from "@manifesto-ai/governance";
 
 const governed = withGovernance(
-  createManifesto<CounterDomain>(schema, effects),
+  withLineage(createManifesto<CounterDomain>(schema, effects), {
+    store: createInMemoryLineageStore(),
+  }),
   {
-    lineage: { store },
     bindings,
     execution: {
       projectionId: "counter",
@@ -44,9 +46,9 @@ const proposal = await governed.proposeAsync(
 
 ## What Changes After Governance Activation
 
-- direct `dispatchAsync` no longer exists
+- direct `dispatchAsync` and `commitAsync` no longer exist
 - the canonical state-change path becomes `proposeAsync() -> approve()/reject()`
-- lineage is guaranteed at runtime
+- lineage must be composed before governance activation
 - visible snapshots publish only after approved execution seals successfully
 
 ## Low-Level Surface Still Available

package/dist/authority/auto.d.ts

@@ -0,0 +1,6 @@
+import type { ActorAuthorityBinding, AuthorityResponse, Proposal } from "../types.js";
+import type { AuthorityHandler } from "./types.js";
+export declare class AutoApproveHandler implements AuthorityHandler {
+    evaluate(proposal: Proposal, binding: ActorAuthorityBinding): Promise<AuthorityResponse>;
+}
+export declare function createAutoApproveHandler(): AutoApproveHandler;

package/dist/authority/evaluator.d.ts

@@ -0,0 +1,33 @@
+import type { ActorAuthorityBinding, AuthorityKind, AuthorityResponse, IntentScope, Proposal } from "../types.js";
+import type { AuthorityHandler } from "./types.js";
+import { AutoApproveHandler } from "./auto.js";
+import { HITLHandler } from "./hitl.js";
+import { PolicyRulesHandler } from "./policy.js";
+import { TribunalHandler } from "./tribunal.js";
+export 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;
+}
+export declare function createAuthorityEvaluator(): AuthorityEvaluator;

package/dist/authority/hitl.d.ts

@@ -0,0 +1,14 @@
+import type { ActorAuthorityBinding, AuthorityResponse, IntentScope, Proposal } from "../types.js";
+import type { AuthorityHandler } from "./types.js";
+export type HITLNotificationCallback = (proposalId: string, proposal: Proposal, binding: ActorAuthorityBinding) => void;
+export 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;
+}
+export declare function createHITLHandler(): HITLHandler;

package/dist/authority/policy.d.ts

@@ -0,0 +1,12 @@
+import type { ActorAuthorityBinding, AuthorityResponse, Proposal } from "../types.js";
+import type { AuthorityHandler } from "./types.js";
+export type CustomConditionEvaluator = (proposal: Proposal, binding: ActorAuthorityBinding) => boolean;
+export 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;
+}
+export declare function createPolicyRulesHandler(): PolicyRulesHandler;

package/dist/authority/tribunal.d.ts

@@ -0,0 +1,16 @@
+import type { ActorAuthorityBinding, ActorRef, AuthorityResponse, Proposal, Vote } from "../types.js";
+import type { AuthorityHandler } from "./types.js";
+export type TribunalNotificationCallback = (proposalId: string, proposal: Proposal, members: readonly ActorRef[]) => void;
+export 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;
+}
+export declare function createTribunalHandler(): TribunalHandler;

package/dist/authority/types.d.ts

@@ -0,0 +1,14 @@
+import type { ActorAuthorityBinding, AuthorityResponse, Proposal } from "../types.js";
+export interface AuthorityHandler {
+    evaluate(proposal: Proposal, binding: ActorAuthorityBinding): Promise<AuthorityResponse>;
+}
+export interface HITLDecisionCallback {
+    (proposalId: string, decision: "approved" | "rejected", reasoning?: string): void;
+}
+export interface HITLPendingState {
+    proposalId: string;
+    proposal?: Proposal;
+    resolve: (response: AuthorityResponse) => void;
+    reject: (error: Error) => void;
+    timeoutId?: ReturnType<typeof setTimeout>;
+}

package/dist/event-dispatcher.d.ts

@@ -0,0 +1,7 @@
+import { type GovernanceEventDispatcher, type GovernanceEventSink, type GovernanceService } from "./types.js";
+export interface CreateGovernanceEventDispatcherOptions {
+    readonly service: Pick<GovernanceService, "createExecutionCompletedEvent" | "createExecutionFailedEvent" | "createWorldCreatedEvent" | "createWorldForkedEvent">;
+    readonly sink?: GovernanceEventSink;
+    readonly now?: () => number;
+}
+export declare function createGovernanceEventDispatcher(options: CreateGovernanceEventDispatcherOptions): GovernanceEventDispatcher;