@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/fixture-support.d.ts

@@ -1,24 +0,0 @@
-export type FixtureInjectionMode = 'workspace-link' | 'installed-link' | 'contracts-only';
-export type FixtureSupportDeclaration = {
-    packageName: string;
-    modes: readonly FixtureInjectionMode[];
-    workspaceDirName?: string;
-    entrySpecifier?: string;
-    contractsShim?: 'agent-contracts';
-};
-export type ResolveSharedFixtureOptions = {
-    packageRoot?: string;
-    requiredPaths?: string[];
-};
-export type PrepareFixturePackagesOptions = {
-    fixtureRoot: string;
-    packageRoot?: string;
-    declarations: readonly FixtureSupportDeclaration[];
-};
-export declare const DEFAULT_FIXTURE_ID = "treeseed-working-site";
-export declare function resolveRequestedFixtureId(): string;
-export declare function resolveFixturesRepoRoot(options?: ResolveSharedFixtureOptions): string;
-export declare function resolveSharedFixtureRoot(options?: ResolveSharedFixtureOptions): string | null;
-export declare function requireSharedFixtureRoot(options?: ResolveSharedFixtureOptions): string;
-export declare function checkSharedFixture(options?: ResolveSharedFixtureOptions): string;
-export declare function prepareFixturePackages(options: PrepareFixturePackagesOptions): void;

package/dist/fixture-support.js

@@ -1,385 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-const require2 = createRequire(import.meta.url);
-const sdkPackageRoot = resolve(fileURLToPath(new URL("..", import.meta.url)));
-const DEFAULT_FIXTURE_ID = "treeseed-working-site";
-function currentPackageRoot(packageRoot) {
-  return packageRoot ? resolve(packageRoot) : sdkPackageRoot;
-}
-function requiredFixturePaths(requiredPaths) {
-  return requiredPaths && requiredPaths.length > 0 ? requiredPaths : ["src/manifest.yaml", "src/content"];
-}
-function resolveRequestedFixtureId() {
-  return process.env.TREESEED_FIXTURE_ID?.trim() || DEFAULT_FIXTURE_ID;
-}
-function resolveFixturesRepoRoot(options = {}) {
-  if (process.env.TREESEED_FIXTURES_ROOT?.trim()) {
-    return resolve(process.env.TREESEED_FIXTURES_ROOT);
-  }
-  return resolve(currentPackageRoot(options.packageRoot), ".fixtures", "treeseed-fixtures");
-}
-function fixtureSatisfiesRequiredPaths(root, requiredPaths) {
-  return requiredFixturePaths(requiredPaths).every((relativePath) => existsSync(join(root, relativePath)));
-}
-function resolveSharedFixtureRoot(options = {}) {
-  const fixturesRepoRoot = resolveFixturesRepoRoot(options);
-  const sitesRoot = join(fixturesRepoRoot, "sites");
-  if (!existsSync(sitesRoot)) {
-    return null;
-  }
-  const requestedFixtureId = resolveRequestedFixtureId();
-  for (const entry of readdirSync(sitesRoot, { withFileTypes: true })) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    const fixtureRoot = join(sitesRoot, entry.name);
-    const manifestPath = join(fixtureRoot, "fixture.manifest.json");
-    if (!existsSync(manifestPath)) {
-      continue;
-    }
-    try {
-      const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-      if (manifest.id !== requestedFixtureId) {
-        continue;
-      }
-      const root = resolve(fixtureRoot, manifest.root ?? ".");
-      if (fixtureSatisfiesRequiredPaths(root, options.requiredPaths)) {
-        return root;
-      }
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-function requireSharedFixtureRoot(options = {}) {
-  const fixtureRoot = resolveSharedFixtureRoot(options);
-  if (!fixtureRoot) {
-    throw new Error(
-      `Unable to resolve shared fixture "${resolveRequestedFixtureId()}". Initialize the submodule with "git submodule update --init --recursive".`
-    );
-  }
-  return fixtureRoot;
-}
-function checkSharedFixture(options = {}) {
-  const fixtureRoot = requireSharedFixtureRoot(options);
-  const missing = requiredFixturePaths(options.requiredPaths).filter((relativePath) => !existsSync(join(fixtureRoot, relativePath)));
-  if (missing.length > 0) {
-    throw new Error(`Shared fixture is missing required paths at ${fixtureRoot}: ${missing.join(", ")}.`);
-  }
-  return fixtureRoot;
-}
-function resolveInstalledPackageRoot(packageName, entrySpecifier) {
-  const candidates = [
-    `${packageName}/package.json`,
-    entrySpecifier ?? packageName,
-    packageName
-  ];
-  for (const candidate of candidates) {
-    try {
-      const resolvedEntry = require2.resolve(candidate);
-      let currentDir = dirname(resolvedEntry);
-      while (currentDir !== dirname(currentDir)) {
-        if (existsSync(resolve(currentDir, "package.json"))) {
-          return currentDir;
-        }
-        currentDir = dirname(currentDir);
-      }
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-function resolveWorkspacePackageRoot(packageRoot, workspaceDirName) {
-  if (!workspaceDirName) {
-    return null;
-  }
-  const candidate = resolve(packageRoot, "..", workspaceDirName);
-  return existsSync(resolve(candidate, "package.json")) ? candidate : null;
-}
-function packageProvidesEntry(packageRoot, entrySpecifier) {
-  if (!entrySpecifier) {
-    return true;
-  }
-  try {
-    const packageRequire = createRequire(resolve(packageRoot, "package.json"));
-    packageRequire.resolve(entrySpecifier);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function exportKeyForEntry(packageName, entrySpecifier) {
-  if (!entrySpecifier || entrySpecifier === packageName) {
-    return ".";
-  }
-  if (!entrySpecifier.startsWith(`${packageName}/`)) {
-    return null;
-  }
-  return `.${entrySpecifier.slice(packageName.length)}`;
-}
-function exportTargets(value) {
-  if (typeof value === "string") {
-    return [value];
-  }
-  if (!value || typeof value !== "object") {
-    return [];
-  }
-  const record = value;
-  return ["types", "import", "default", "require"].flatMap((key) => exportTargets(record[key]));
-}
-function workspacePackageProvidesEntry(packageRoot, packageName, entrySpecifier) {
-  const exportKey = exportKeyForEntry(packageName, entrySpecifier);
-  if (!exportKey) {
-    return false;
-  }
-  if (exportKey === "." && !entrySpecifier) {
-    return true;
-  }
-  try {
-    const packageJson = JSON.parse(readFileSync(resolve(packageRoot, "package.json"), "utf8"));
-    const entryExport = typeof packageJson.exports === "string" ? exportKey === "." ? packageJson.exports : null : packageJson.exports?.[exportKey];
-    const targets = exportTargets(entryExport);
-    return targets.length > 0 && targets.every((target) => existsSync(resolve(packageRoot, target)));
-  } catch {
-    return false;
-  }
-}
-function ensureFixtureLinkedPackage(fixtureRoot, packageName, resolvedPackageRoot) {
-  const packageDir = resolve(fixtureRoot, "node_modules", ...packageName.split("/"));
-  mkdirSync(dirname(packageDir), { recursive: true });
-  rmSync(packageDir, { recursive: true, force: true });
-  symlinkSync(resolvedPackageRoot, packageDir, "dir");
-}
-function buildAgentContractsShimPackage(fixtureRoot) {
-  const packageDir = resolve(fixtureRoot, "node_modules", "@treeseed", "agent");
-  rmSync(packageDir, { recursive: true, force: true });
-  mkdirSync(resolve(packageDir, "contracts"), { recursive: true });
-  writeFileSync(
-    resolve(packageDir, "package.json"),
-    JSON.stringify(
-      {
-        name: "@treeseed/agent",
-        type: "module",
-        exports: {
-          "./runtime-types": {
-            types: "./runtime-types.d.js",
-            default: "./runtime-types.js"
-          },
-          "./contracts/messages": {
-            types: "./contracts/messages.d.js",
-            default: "./contracts/messages.js"
-          },
-          "./contracts/run": {
-            types: "./contracts/run.d.js",
-            default: "./contracts/run.js"
-          }
-        }
-      },
-      null,
-      2
-    ),
-    "utf8"
-  );
-  writeFileSync(resolve(packageDir, "runtime-types.js"), "export {};\n", "utf8");
-  writeFileSync(
-    resolve(packageDir, "runtime-types.d.ts"),
-    [
-      "import type { AgentHandlerKind, AgentRunStatus } from '@treeseed/sdk/types/agents';",
-      "export interface AgentTriggerInvocation {",
-      "	kind: 'startup' | 'schedule' | 'message' | 'manual' | 'follow';",
-      "	source: string;",
-      "	message?: { id?: string | number; type?: string; payloadJson?: string | null } | null;",
-      "}",
-      "export interface AgentHandlerOutput {",
-      "	status: AgentRunStatus;",
-      "	summary: string;",
-      "	stdout?: string;",
-      "	stderr?: string;",
-      "	errorCategory?: import('./contracts/run').AgentErrorCategory | null;",
-      "	metadata?: Record<string, unknown>;",
-      "}",
-      "export interface AgentContext {",
-      "	runId: string;",
-      "	repoRoot: string;",
-      "	agent: any;",
-      "	sdk: any;",
-      "	trigger: AgentTriggerInvocation;",
-      "	execution: any;",
-      "	mutations: any;",
-      "	repository: any;",
-      "	verification: any;",
-      "	notifications: any;",
-      "	research: any;",
-      "}",
-      "export interface AgentHandler<TInputs = unknown, TResult = unknown> {",
-      "	kind: AgentHandlerKind;",
-      "	resolveInputs(context: AgentContext): Promise<TInputs>;",
-      "	execute(context: AgentContext, inputs: TInputs): Promise<TResult>;",
-      "	emitOutputs(context: AgentContext, result: TResult): Promise<AgentHandlerOutput>;",
-      "}",
-      ""
-    ].join("\n"),
-    "utf8"
-  );
-  writeFileSync(
-    resolve(packageDir, "contracts", "messages.js"),
-    [
-      "export const AGENT_MESSAGE_TYPES = [];",
-      "export function parseAgentMessagePayload(_type, payloadJson) {",
-      "	return JSON.parse(payloadJson);",
-      "}",
-      ""
-    ].join("\n"),
-    "utf8"
-  );
-  writeFileSync(
-    resolve(packageDir, "contracts", "messages.d.ts"),
-    [
-      "export interface QuestionPriorityUpdatedMessage {",
-      "	questionId: string;",
-      "	reason: string;",
-      "	plannerRunId: string;",
-      "}",
-      "export interface ObjectivePriorityUpdatedMessage {",
-      "	objectiveId: string;",
-      "	reason: string;",
-      "	plannerRunId: string;",
-      "}",
-      "export interface ArchitectureUpdatedMessage {",
-      "	objectiveId: string;",
-      "	knowledgeId: string;",
-      "	architectRunId: string;",
-      "}",
-      "export interface SubscriberNotifiedMessage {",
-      "	email: string;",
-      "	itemCount: number;",
-      "	notifierRunId: string;",
-      "}",
-      "export interface ResearchStartedMessage {",
-      "	questionId: string;",
-      "	researcherRunId: string;",
-      "}",
-      "export interface ResearchCompletedMessage {",
-      "	questionId: string;",
-      "	knowledgeId: string | null;",
-      "	researcherRunId: string;",
-      "}",
-      "export interface TaskCompleteMessage {",
-      "	branchName: string | null;",
-      "	changedTargets: string[];",
-      "	engineerRunId: string;",
-      "}",
-      "export interface TaskWaitingMessage {",
-      "	blockingReason: string;",
-      "	engineerRunId: string;",
-      "}",
-      "export interface TaskFailedMessage {",
-      "	failureSummary: string;",
-      "	engineerRunId: string;",
-      "}",
-      "export interface TaskVerifiedMessage {",
-      "	branchName: string | null;",
-      "	reviewerRunId: string;",
-      "}",
-      "export interface ReviewFailedMessage {",
-      "	failureSummary: string;",
-      "	reviewerRunId: string;",
-      "}",
-      "export interface ReviewWaitingMessage {",
-      "	blockingReason: string;",
-      "	reviewerRunId: string;",
-      "}",
-      "export interface ReleaseStartedMessage {",
-      "	taskRunId: string | null;",
-      "	releaserRunId: string;",
-      "}",
-      "export interface ReleaseCompletedMessage {",
-      "	releaseSummary: string;",
-      "	releaserRunId: string;",
-      "}",
-      "export interface ReleaseFailedMessage {",
-      "	failureSummary: string;",
-      "	releaserRunId: string;",
-      "}",
-      "export interface AgentMessageContracts {",
-      "	question_priority_updated: QuestionPriorityUpdatedMessage;",
-      "	objective_priority_updated: ObjectivePriorityUpdatedMessage;",
-      "	architecture_updated: ArchitectureUpdatedMessage;",
-      "	subscriber_notified: SubscriberNotifiedMessage;",
-      "	research_started: ResearchStartedMessage;",
-      "	research_completed: ResearchCompletedMessage;",
-      "	task_complete: TaskCompleteMessage;",
-      "	task_waiting: TaskWaitingMessage;",
-      "	task_failed: TaskFailedMessage;",
-      "	task_verified: TaskVerifiedMessage;",
-      "	review_failed: ReviewFailedMessage;",
-      "	review_waiting: ReviewWaitingMessage;",
-      "	release_started: ReleaseStartedMessage;",
-      "	release_completed: ReleaseCompletedMessage;",
-      "	release_failed: ReleaseFailedMessage;",
-      "}",
-      "export type AgentMessageType = keyof AgentMessageContracts;",
-      "export type AgentMessagePayload<TType extends AgentMessageType> = AgentMessageContracts[TType];",
-      "export declare const AGENT_MESSAGE_TYPES: readonly AgentMessageType[];",
-      "export declare function parseAgentMessagePayload<TType extends AgentMessageType>(_type: TType, payloadJson: string): AgentMessagePayload<TType>;",
-      ""
-    ].join("\n"),
-    "utf8"
-  );
-  writeFileSync(resolve(packageDir, "contracts", "run.js"), "export {};\n", "utf8");
-  writeFileSync(
-    resolve(packageDir, "contracts", "run.d.ts"),
-    [
-      "export type AgentErrorCategory = 'execution_error' | 'mutation_error' | 'verification_error' | 'notification_error' | 'research_error' | 'sdk_error' | 'unknown';",
-      ""
-    ].join("\n"),
-    "utf8"
-  );
-}
-function prepareFixturePackages(options) {
-  const packageRoot = currentPackageRoot(options.packageRoot);
-  for (const declaration of options.declarations) {
-    let satisfied = false;
-    for (const mode of declaration.modes) {
-      if (mode === "workspace-link") {
-        const workspaceRoot = resolveWorkspacePackageRoot(packageRoot, declaration.workspaceDirName);
-        if (!workspaceRoot || !workspacePackageProvidesEntry(workspaceRoot, declaration.packageName, declaration.entrySpecifier)) {
-          continue;
-        }
-        ensureFixtureLinkedPackage(options.fixtureRoot, declaration.packageName, workspaceRoot);
-        satisfied = true;
-        break;
-      }
-      if (mode === "installed-link") {
-        const installedRoot = resolveInstalledPackageRoot(declaration.packageName, declaration.entrySpecifier);
-        if (!installedRoot || !packageProvidesEntry(installedRoot, declaration.entrySpecifier)) {
-          continue;
-        }
-        ensureFixtureLinkedPackage(options.fixtureRoot, declaration.packageName, installedRoot);
-        satisfied = true;
-        break;
-      }
-      if (mode === "contracts-only" && declaration.contractsShim === "agent-contracts") {
-        buildAgentContractsShimPackage(options.fixtureRoot);
-        satisfied = true;
-        break;
-      }
-    }
-    if (!satisfied) {
-      throw new Error(`Unable to prepare fixture package "${declaration.packageName}" using modes ${declaration.modes.join(", ")}.`);
-    }
-  }
-}
-export {
-  DEFAULT_FIXTURE_ID,
-  checkSharedFixture,
-  prepareFixturePackages,
-  requireSharedFixtureRoot,
-  resolveFixturesRepoRoot,
-  resolveRequestedFixtureId,
-  resolveSharedFixtureRoot
-};

package/dist/frontmatter.d.ts

@@ -1,6 +0,0 @@
-export interface ParsedMarkdownDocument {
-    frontmatter: Record<string, unknown>;
-    body: string;
-}
-export declare function parseFrontmatterDocument(source: string): ParsedMarkdownDocument;
-export declare function serializeFrontmatterDocument(frontmatter: Record<string, unknown>, body: string): string;

package/dist/frontmatter.js

@@ -1,33 +0,0 @@
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-function parseFrontmatterDocument(source) {
-  if (!source.startsWith("---\n")) {
-    return {
-      frontmatter: {},
-      body: source
-    };
-  }
-  const delimiterIndex = source.indexOf("\n---\n", 4);
-  if (delimiterIndex < 0) {
-    return {
-      frontmatter: {},
-      body: source
-    };
-  }
-  const yamlSource = source.slice(4, delimiterIndex);
-  const body = source.slice(delimiterIndex + 5);
-  const parsed = parseYaml(yamlSource);
-  return {
-    frontmatter: parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {},
-    body
-  };
-}
-function serializeFrontmatterDocument(frontmatter, body) {
-  return `---
-${stringifyYaml(frontmatter).trimEnd()}
----
-${body.replace(/^\n*/, "")}`;
-}
-export {
-  parseFrontmatterDocument,
-  serializeFrontmatterDocument
-};

package/dist/git-runtime.d.ts

@@ -1,16 +0,0 @@
-export interface GitMutationResult {
-    branchName: string;
-    commitMessage: string;
-    worktreePath: string;
-    commitSha: string | null;
-    changedPaths: string[];
-}
-export declare class GitRuntime {
-    private readonly repoRoot;
-    private readonly disabled;
-    constructor(repoRoot: string, disabled?: boolean);
-    currentBranch(): Promise<string>;
-    ensureWorktree(branchName: string): Promise<string>;
-    commitFileChange(filePath: string, branchName: string, commitMessage: string): Promise<GitMutationResult>;
-    commitFileChanges(filePaths: string[], branchName: string, commitMessage: string): Promise<GitMutationResult>;
-}

package/dist/git-runtime.js

@@ -1,69 +0,0 @@
-import { execFile } from "node:child_process";
-import path from "node:path";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-class GitRuntime {
-  constructor(repoRoot, disabled = false) {
-    this.repoRoot = repoRoot;
-    this.disabled = disabled;
-  }
-  repoRoot;
-  disabled;
-  async currentBranch() {
-    const { stdout } = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-      cwd: this.repoRoot
-    });
-    return stdout.trim();
-  }
-  async ensureWorktree(branchName) {
-    const worktreePath = path.join(this.repoRoot, ".agent-worktrees", branchName);
-    if (this.disabled) {
-      return worktreePath;
-    }
-    try {
-      await execFileAsync("git", ["worktree", "list", "--porcelain"], {
-        cwd: this.repoRoot
-      }).then(async ({ stdout }) => {
-        if (stdout.includes(`worktree ${worktreePath}`)) {
-          await execFileAsync("git", ["switch", branchName], { cwd: worktreePath });
-          return;
-        }
-        await execFileAsync("git", ["worktree", "add", "-B", branchName, worktreePath, "HEAD"], {
-          cwd: this.repoRoot
-        });
-      });
-    } catch {
-      await execFileAsync("git", ["worktree", "add", "-B", branchName, worktreePath, "HEAD"], {
-        cwd: this.repoRoot
-      });
-    }
-    return worktreePath;
-  }
-  async commitFileChange(filePath, branchName, commitMessage) {
-    return this.commitFileChanges([filePath], branchName, commitMessage);
-  }
-  async commitFileChanges(filePaths, branchName, commitMessage) {
-    const worktreePath = await this.ensureWorktree(branchName);
-    if (this.disabled) {
-      return { branchName, commitMessage, worktreePath, commitSha: null, changedPaths: filePaths };
-    }
-    const relativeFilePaths = filePaths.map((filePath) => path.relative(worktreePath, filePath));
-    await execFileAsync("git", ["add", ...relativeFilePaths], { cwd: worktreePath });
-    try {
-      await execFileAsync("git", ["commit", "-m", commitMessage], { cwd: worktreePath });
-    } catch (error) {
-      const stderr = error && typeof error === "object" && "stderr" in error ? String(error.stderr ?? "") : "";
-      const stdout2 = error && typeof error === "object" && "stdout" in error ? String(error.stdout ?? "") : "";
-      if (!`${stdout2}
-${stderr}`.includes("nothing to commit")) {
-        throw error;
-      }
-    }
-    const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: worktreePath });
-    const commitSha = stdout.trim();
-    return { branchName, commitMessage, worktreePath, commitSha, changedPaths: filePaths };
-  }
-}
-export {
-  GitRuntime
-};

package/dist/governance.d.ts

@@ -1,133 +0,0 @@
-export type GovernanceScope = 'project' | 'commons' | 'team';
-export type GovernanceVoteValue = 'support' | 'object' | 'abstain';
-export type GovernanceOutcomeStatus = 'voting' | 'accepted' | 'rejected' | 'no_decision_quorum_failed';
-export type GovernanceOutcomeReason = 'support_threshold_met' | 'object_threshold_met' | 'deadline_support_failed' | 'deadline_quorum_failed' | 'admin_approved' | 'admin_rejected' | 'manual_override' | 'still_open';
-export interface GovernanceRuleInput {
-    teamId: string;
-    projectId?: string | null;
-    scope: GovernanceScope;
-    proposalType?: string | null;
-    providerConfig: Record<string, unknown>;
-}
-export interface GovernanceRuleDescription {
-    providerId: string;
-    providerVersion: string;
-    label: string;
-    summary: string;
-    config: Record<string, unknown>;
-}
-export interface GovernanceChamberSnapshot {
-    id: string;
-    label: string;
-    kind: 'member_equal' | 'stake_weighted' | 'admin' | 'custom';
-    eligibleWeightTotal: number;
-    activeWeightTotal: number;
-    quorumWeightRequired: number;
-    supportWeightRequired: number;
-    objectWeightRequired?: number;
-}
-export interface GovernanceEligibleVoter {
-    userId: string;
-    participantId?: string | null;
-    teamMemberId?: string | null;
-    activeForQuorum: boolean;
-    chambers: Array<{
-        chamberId: string;
-        eligible: boolean;
-        weight: number;
-        source: string;
-        evidence: Record<string, unknown>;
-    }>;
-}
-export interface GovernanceDelegationSnapshot {
-    id: string;
-    fromUserId: string;
-    toUserId: string;
-    scope: string;
-    chambers: string[];
-    status: 'active' | 'revoked' | 'expired' | string;
-    reason?: string | null;
-    createdAt?: string | null;
-}
-export interface GovernanceElectorateInput extends GovernanceRuleInput {
-    eligibleVoters: GovernanceEligibleVoter[];
-    delegations?: GovernanceDelegationSnapshot[];
-    createdAt?: string;
-}
-export interface GovernanceElectorateSnapshot {
-    providerId: string;
-    providerVersion: string;
-    ruleSnapshot: Record<string, unknown>;
-    chambers: GovernanceChamberSnapshot[];
-    eligibleVoters: GovernanceEligibleVoter[];
-    delegations: GovernanceDelegationSnapshot[];
-    createdAt: string;
-}
-export interface GovernanceVoteInput {
-    proposalId: string;
-    proposalVersion: number;
-    userId: string;
-    vote: GovernanceVoteValue;
-    reason?: string | null;
-    chamberOverrides?: Record<string, unknown>;
-}
-export interface GovernanceVoteRecord {
-    proposalId: string;
-    proposalVersion: number;
-    userId: string;
-    vote: GovernanceVoteValue;
-    reason: string | null;
-    chamberVotes: Record<string, GovernanceVoteValue>;
-}
-export interface GovernanceEvaluationVote {
-    userId: string;
-    vote: GovernanceVoteValue;
-    weight?: number;
-    reason?: string | null;
-    chamberVotes?: Record<string, GovernanceVoteValue>;
-    effectiveWeights?: Record<string, number>;
-    delegatedFrom?: string[];
-}
-export interface GovernanceEvaluationInput {
-    now?: string;
-    votingEndsAt?: string | null;
-    electorate: GovernanceElectorateSnapshot;
-    votes: GovernanceEvaluationVote[];
-    adminDecision?: 'approved' | 'rejected' | 'request_changes' | null;
-}
-export interface GovernanceChamberResult {
-    chamberId: string;
-    label: string;
-    status: GovernanceOutcomeStatus;
-    supportWeight: number;
-    objectWeight: number;
-    abstainWeight: number;
-    participatingWeight: number;
-    quorumWeightRequired: number;
-    supportWeightRequired: number;
-    objectWeightRequired?: number;
-    quorumMet: boolean;
-    reasonCode: GovernanceOutcomeReason;
-}
-export interface GovernanceOutcome {
-    status: GovernanceOutcomeStatus;
-    reasonCode: GovernanceOutcomeReason;
-    chamberResults: GovernanceChamberResult[];
-    voteResult: Record<string, unknown>;
-    decisionEligible: boolean;
-}
-export interface GovernanceVotingProvider {
-    id: string;
-    label: string;
-    version: string;
-    describeRule(input: GovernanceRuleInput): GovernanceRuleDescription;
-    snapshotElectorate(input: GovernanceElectorateInput): Promise<GovernanceElectorateSnapshot> | GovernanceElectorateSnapshot;
-    normalizeVote(input: GovernanceVoteInput): GovernanceVoteRecord;
-    evaluate(input: GovernanceEvaluationInput): GovernanceOutcome;
-}
-export declare const adminApprovalProvider: GovernanceVotingProvider;
-export declare const simpleMajorityProvider: GovernanceVotingProvider;
-export declare const absoluteThresholdProvider: GovernanceVotingProvider;
-export declare const treeseedBicameralProvider: GovernanceVotingProvider;
-export declare const governanceVotingProviders: Record<string, GovernanceVotingProvider>;
-export declare function governanceVotingProvider(id: string | null | undefined): GovernanceVotingProvider;