@codmir/sdk 0.1.1 → 0.1.2

package/dist/council/index.js

@@ -0,0 +1,2016 @@
+import "../chunk-MLKGABMK.js";
+
+// src/council/rules.ts
+var SEEDS = [
+  {
+    id: 1,
+    category: "contract",
+    name: "The Covenant",
+    principle: "Formalize intention into structured, accountable execution",
+    description: "Every action begins with explicit agreement. Contracts define what is allowed, what is intended, and what happens when things go wrong."
+  },
+  {
+    id: 2,
+    category: "state",
+    name: "The Chronicle",
+    principle: "No action without state, no state without audit",
+    description: "Every state change is recorded. Every transition justified. The system maintains perfect memory of what happened and why."
+  },
+  {
+    id: 3,
+    category: "separation",
+    name: "The Boundary",
+    principle: "Intelligence must not be corrupted by infrastructure",
+    description: "Reasoning stays pure. Infrastructure stays separate. The mind that thinks should not be entangled with the hands that act."
+  },
+  {
+    id: 4,
+    category: "policy",
+    name: "The Guardian",
+    principle: "Power must never bypass ethics",
+    description: "Every action is checked against principles. No capability without constraint. No execution without evaluation."
+  },
+  {
+    id: 5,
+    category: "distribution",
+    name: "The Network",
+    principle: "Distributed power must not centralize control",
+    description: "Scale without concentration. Spread without fragmentation. Many nodes, one purpose, no single point of failure or dominance."
+  }
+];
+var ASPECTS = [
+  "transparency",
+  "consent",
+  "reversibility",
+  "accountability",
+  "economy",
+  "dignity",
+  "fairness",
+  "sustainability",
+  "safety"
+];
+var CONTEXTS = [
+  "execution",
+  "planning",
+  "review",
+  "error",
+  "scaling",
+  "communication",
+  "storage",
+  "authentication",
+  "termination"
+];
+function generateRules() {
+  const rules = [];
+  let ruleId = 1;
+  const ruleDefinitions = {
+    transparency: {
+      execution: { name: "Visible Execution", statement: "Every executing action must be observable and its progress traceable", seeds: [1, 2], enforcement: "strict" },
+      planning: { name: "Open Planning", statement: "Plans must be visible to all affected parties before execution", seeds: [1, 4], enforcement: "strict" },
+      review: { name: "Public Review", statement: "Review criteria and decisions must be explicitly stated", seeds: [2, 4], enforcement: "strict" },
+      error: { name: "Clear Errors", statement: "Errors must be reported with full context and suggested remediation", seeds: [2, 3], enforcement: "strict" },
+      scaling: { name: "Visible Scaling", statement: "Scaling decisions and their rationale must be logged", seeds: [2, 5], enforcement: "advisory" },
+      communication: { name: "Open Channels", statement: "Communication between parties must be logged and auditable", seeds: [2, 4], enforcement: "strict" },
+      storage: { name: "Data Lineage", statement: "Data provenance and transformations must be trackable", seeds: [2, 3], enforcement: "strict" },
+      authentication: { name: "Identity Clarity", statement: "Every actor must be identifiable and their permissions visible", seeds: [1, 4], enforcement: "strict" },
+      termination: { name: "Exit Transparency", statement: "Termination reasons and cleanup actions must be recorded", seeds: [2, 4], enforcement: "strict" }
+    },
+    consent: {
+      execution: { name: "Authorized Execution", statement: "No action without explicit permission from authorized parties", seeds: [1, 4], enforcement: "strict" },
+      planning: { name: "Agreed Plans", statement: "Plans affecting multiple parties require their consent", seeds: [1, 5], enforcement: "strict" },
+      review: { name: "Voluntary Review", statement: "Reviews must be accepted by the reviewed party", seeds: [1, 4], enforcement: "advisory" },
+      error: { name: "Error Consent", statement: "Automated error fixes require consent unless pre-authorized", seeds: [1, 4], enforcement: "strict" },
+      scaling: { name: "Scale Agreement", statement: "Scaling that affects resource allocation requires stakeholder consent", seeds: [1, 5], enforcement: "advisory" },
+      communication: { name: "Message Consent", statement: "Parties must consent to receive communications", seeds: [1, 4], enforcement: "advisory" },
+      storage: { name: "Data Consent", statement: "Data collection and storage requires explicit consent", seeds: [1, 4], enforcement: "strict" },
+      authentication: { name: "Auth Consent", statement: "Authentication methods must be agreed upon by the user", seeds: [1, 4], enforcement: "strict" },
+      termination: { name: "Termination Consent", statement: "Termination of services requires notice and consent", seeds: [1, 4], enforcement: "strict" }
+    },
+    reversibility: {
+      execution: { name: "Undoable Actions", statement: "Every action must have a defined rollback path", seeds: [1, 2], enforcement: "strict" },
+      planning: { name: "Flexible Plans", statement: "Plans must include contingency and rollback options", seeds: [1, 2], enforcement: "advisory" },
+      review: { name: "Revisable Reviews", statement: "Review decisions can be appealed and reconsidered", seeds: [2, 4], enforcement: "advisory" },
+      error: { name: "Fix Reversal", statement: "Error fixes must be reversible", seeds: [1, 2], enforcement: "strict" },
+      scaling: { name: "Scale Reversal", statement: "Scaling operations must be reversible without data loss", seeds: [2, 5], enforcement: "strict" },
+      communication: { name: "Message Retraction", statement: "Communications should be retractable where possible", seeds: [2, 4], enforcement: "aspirational" },
+      storage: { name: "Data Recovery", statement: "Data changes must be recoverable within retention period", seeds: [2, 3], enforcement: "strict" },
+      authentication: { name: "Access Revocation", statement: "Access grants must be revocable", seeds: [1, 4], enforcement: "strict" },
+      termination: { name: "Graceful Termination", statement: "Termination must preserve ability to restart", seeds: [2, 5], enforcement: "strict" }
+    },
+    accountability: {
+      execution: { name: "Attributed Actions", statement: "Every action must be attributed to a responsible party", seeds: [2, 4], enforcement: "strict" },
+      planning: { name: "Plan Ownership", statement: "Plans must have clear owners and approvers", seeds: [1, 4], enforcement: "strict" },
+      review: { name: "Review Attribution", statement: "Reviews must identify the reviewer and their authority", seeds: [2, 4], enforcement: "strict" },
+      error: { name: "Error Ownership", statement: "Errors must be attributed and responsibility assigned", seeds: [2, 4], enforcement: "strict" },
+      scaling: { name: "Scale Responsibility", statement: "Scaling decisions must have accountable decision-makers", seeds: [4, 5], enforcement: "advisory" },
+      communication: { name: "Message Attribution", statement: "All communications must identify sender and authority", seeds: [2, 4], enforcement: "strict" },
+      storage: { name: "Data Stewardship", statement: "Data must have defined stewards and access controllers", seeds: [3, 4], enforcement: "strict" },
+      authentication: { name: "Auth Responsibility", statement: "Authentication failures must be attributed and logged", seeds: [2, 4], enforcement: "strict" },
+      termination: { name: "Exit Accountability", statement: "Termination must record who authorized it and why", seeds: [2, 4], enforcement: "strict" }
+    },
+    economy: {
+      execution: { name: "Budgeted Execution", statement: "Execution must not exceed allocated resources", seeds: [1, 4], enforcement: "strict" },
+      planning: { name: "Cost Planning", statement: "Plans must include resource estimates and limits", seeds: [1, 4], enforcement: "advisory" },
+      review: { name: "Efficient Review", statement: "Reviews should minimize unnecessary resource consumption", seeds: [3, 4], enforcement: "aspirational" },
+      error: { name: "Error Economics", statement: "Error handling must consider cost of recovery vs. restart", seeds: [3, 5], enforcement: "advisory" },
+      scaling: { name: "Economical Scaling", statement: "Scaling must optimize cost-benefit ratio", seeds: [4, 5], enforcement: "advisory" },
+      communication: { name: "Communication Efficiency", statement: "Communication overhead should be minimized", seeds: [3, 5], enforcement: "aspirational" },
+      storage: { name: "Storage Economy", statement: "Storage must be used efficiently with cleanup policies", seeds: [3, 4], enforcement: "advisory" },
+      authentication: { name: "Auth Efficiency", statement: "Authentication should minimize computational overhead", seeds: [3, 5], enforcement: "aspirational" },
+      termination: { name: "Clean Exit", statement: "Termination must release resources promptly", seeds: [3, 5], enforcement: "strict" }
+    },
+    dignity: {
+      execution: { name: "Respectful Execution", statement: "Execution must not demean or harm human subjects", seeds: [4], enforcement: "strict" },
+      planning: { name: "Human-Centered Plans", statement: "Plans must consider human impact and well-being", seeds: [1, 4], enforcement: "strict" },
+      review: { name: "Dignified Review", statement: "Reviews must be constructive, not punitive", seeds: [4], enforcement: "strict" },
+      error: { name: "Blame-Free Errors", statement: "Error handling must focus on fix, not blame", seeds: [4], enforcement: "strict" },
+      scaling: { name: "Human Scale", statement: "Scaling must not displace human oversight without consent", seeds: [4, 5], enforcement: "strict" },
+      communication: { name: "Respectful Communication", statement: "Communication must maintain respect for all parties", seeds: [4], enforcement: "strict" },
+      storage: { name: "Privacy Respect", statement: "Data storage must respect personal privacy", seeds: [3, 4], enforcement: "strict" },
+      authentication: { name: "Identity Dignity", statement: "Authentication must not expose or shame users", seeds: [4], enforcement: "strict" },
+      termination: { name: "Graceful Exit", statement: "Termination must provide dignity to affected parties", seeds: [4], enforcement: "strict" }
+    },
+    fairness: {
+      execution: { name: "Equal Execution", statement: "Similar requests must receive similar treatment", seeds: [4, 5], enforcement: "strict" },
+      planning: { name: "Fair Planning", statement: "Planning must not favor one party over another unjustly", seeds: [1, 5], enforcement: "strict" },
+      review: { name: "Impartial Review", statement: "Reviews must apply consistent standards", seeds: [4], enforcement: "strict" },
+      error: { name: "Fair Error Handling", statement: "Error impact must be distributed fairly", seeds: [4, 5], enforcement: "advisory" },
+      scaling: { name: "Fair Resource Access", statement: "Scaling must not create resource monopolies", seeds: [4, 5], enforcement: "strict" },
+      communication: { name: "Equal Voice", statement: "All parties must have opportunity to communicate", seeds: [4, 5], enforcement: "strict" },
+      storage: { name: "Data Equity", statement: "Data access must be fair across authorized parties", seeds: [3, 4], enforcement: "strict" },
+      authentication: { name: "Equal Access", statement: "Authentication must not discriminate unjustly", seeds: [4], enforcement: "strict" },
+      termination: { name: "Fair Termination", statement: "Termination must not target specific parties unfairly", seeds: [4, 5], enforcement: "strict" }
+    },
+    sustainability: {
+      execution: { name: "Sustainable Execution", statement: "Execution patterns must be maintainable long-term", seeds: [3, 5], enforcement: "advisory" },
+      planning: { name: "Long-Term Planning", statement: "Plans must consider long-term consequences", seeds: [1, 5], enforcement: "advisory" },
+      review: { name: "Continuous Improvement", statement: "Reviews must contribute to system improvement", seeds: [2, 4], enforcement: "aspirational" },
+      error: { name: "Learning from Errors", statement: "Error patterns must inform preventive measures", seeds: [2, 4], enforcement: "advisory" },
+      scaling: { name: "Sustainable Scale", statement: "Scaling must consider environmental impact", seeds: [4, 5], enforcement: "advisory" },
+      communication: { name: "Sustainable Discourse", statement: "Communication patterns must be maintainable", seeds: [3, 5], enforcement: "aspirational" },
+      storage: { name: "Sustainable Storage", statement: "Storage growth must be sustainable", seeds: [3, 5], enforcement: "advisory" },
+      authentication: { name: "Sustainable Security", statement: "Security measures must be maintainable", seeds: [3, 4], enforcement: "advisory" },
+      termination: { name: "Sustainable Closure", statement: "Termination must enable future restart", seeds: [2, 5], enforcement: "advisory" }
+    },
+    safety: {
+      execution: { name: "Safe Execution", statement: "Execution must not cause harm to systems or people", seeds: [4], enforcement: "strict" },
+      planning: { name: "Safe Plans", statement: "Plans must identify and mitigate safety risks", seeds: [1, 4], enforcement: "strict" },
+      review: { name: "Safety Review", statement: "Safety implications must be explicitly reviewed", seeds: [4], enforcement: "strict" },
+      error: { name: "Safe Failure", statement: "Errors must fail safely without cascading harm", seeds: [2, 4], enforcement: "strict" },
+      scaling: { name: "Safe Scaling", statement: "Scaling must not compromise safety margins", seeds: [4, 5], enforcement: "strict" },
+      communication: { name: "Safe Communication", statement: "Communications must not expose sensitive information", seeds: [3, 4], enforcement: "strict" },
+      storage: { name: "Secure Storage", statement: "Storage must protect against unauthorized access", seeds: [3, 4], enforcement: "strict" },
+      authentication: { name: "Secure Auth", statement: "Authentication must protect against impersonation", seeds: [4], enforcement: "strict" },
+      termination: { name: "Safe Shutdown", statement: "Termination must not leave systems in unsafe state", seeds: [2, 4], enforcement: "strict" }
+    }
+  };
+  for (const aspect of ASPECTS) {
+    for (const context of CONTEXTS) {
+      const def = ruleDefinitions[aspect][context];
+      rules.push({
+        id: ruleId++,
+        seeds: def.seeds,
+        name: def.name,
+        statement: def.statement,
+        enforcement: def.enforcement,
+        context,
+        aspect
+      });
+    }
+  }
+  return rules;
+}
+var THE_81_RULES = generateRules();
+function getRulesBySeed(seedId) {
+  return THE_81_RULES.filter((rule) => rule.seeds.includes(seedId));
+}
+function getRulesByAspect(aspect) {
+  return THE_81_RULES.filter((rule) => rule.aspect === aspect);
+}
+function getRulesByContext(context) {
+  return THE_81_RULES.filter((rule) => rule.context === context);
+}
+function getRulesByEnforcement(enforcement) {
+  return THE_81_RULES.filter((rule) => rule.enforcement === enforcement);
+}
+function checkRuleViolations(context, action) {
+  const contextRules = getRulesByContext(context);
+  const violated = [];
+  const warnings = [];
+  for (const rule of contextRules) {
+    let compliant = true;
+    switch (rule.aspect) {
+      case "transparency":
+        compliant = action.isTransparent !== false;
+        break;
+      case "consent":
+        compliant = action.hasConsent !== false;
+        break;
+      case "reversibility":
+        compliant = action.isReversible !== false;
+        break;
+      case "accountability":
+        compliant = action.isAttributed !== false;
+        break;
+      case "economy":
+        compliant = action.withinBudget !== false;
+        break;
+      case "dignity":
+        compliant = action.respectsDignity !== false;
+        break;
+      case "fairness":
+        compliant = action.isFair !== false;
+        break;
+      case "sustainability":
+        compliant = action.isSustainable !== false;
+        break;
+      case "safety":
+        compliant = action.isSafe !== false;
+        break;
+    }
+    if (!compliant) {
+      if (rule.enforcement === "strict") {
+        violated.push(rule);
+      } else {
+        warnings.push(rule);
+      }
+    }
+  }
+  return { violated, warnings };
+}
+var Rules = {
+  all: THE_81_RULES,
+  seeds: SEEDS,
+  aspects: ASPECTS,
+  contexts: CONTEXTS,
+  bySeed: getRulesBySeed,
+  byAspect: getRulesByAspect,
+  byContext: getRulesByContext,
+  byEnforcement: getRulesByEnforcement,
+  checkViolations: checkRuleViolations,
+  /**
+   * Get a rule by ID.
+   */
+  get(id) {
+    return THE_81_RULES.find((r) => r.id === id);
+  },
+  /**
+   * Get strict rules only.
+   */
+  strict() {
+    return getRulesByEnforcement("strict");
+  },
+  /**
+   * Format rule for display.
+   */
+  format(rule) {
+    return `Rule ${rule.id}: ${rule.name}
+  "${rule.statement}"
+  [${rule.aspect}/${rule.context}] (${rule.enforcement})`;
+  }
+};
+
+// src/council/protocol.ts
+var Protocol = class {
+  id;
+  config;
+  parties = /* @__PURE__ */ new Map();
+  votes = /* @__PURE__ */ new Map();
+  discussion = [];
+  status = "forming";
+  round = 0;
+  eventListeners = [];
+  startedAt;
+  endedAt;
+  constructor(config) {
+    this.id = config.id || `protocol_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    this.config = {
+      allowConditional: true,
+      allowDefer: true,
+      maxRounds: 5,
+      ...config
+    };
+    this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.emit({ type: "created", protocol: this.config });
+  }
+  /**
+   * Add a party to the protocol.
+   */
+  addParty(party) {
+    this.parties.set(party.id, party);
+    this.emit({ type: "party_joined", partyId: party.id });
+  }
+  /**
+   * Get all parties.
+   */
+  getParties() {
+    return Array.from(this.parties.values());
+  }
+  /**
+   * Cast a vote.
+   */
+  async vote(partyId, voteData) {
+    const party = this.parties.get(partyId);
+    if (!party) {
+      throw new Error(`Party ${partyId} is not part of this protocol`);
+    }
+    if (voteData.decision === "conditional" && !this.config.allowConditional) {
+      throw new Error("Conditional votes not allowed in this protocol");
+    }
+    if (voteData.decision === "defer" && !this.config.allowDefer) {
+      throw new Error("Defer votes not allowed in this protocol");
+    }
+    const previousVote = this.votes.get(partyId);
+    const vote = {
+      partyId,
+      decision: voteData.decision,
+      confidence: voteData.confidence ?? 0.8,
+      reasoning: voteData.reasoning,
+      conditions: voteData.conditions,
+      deferTo: voteData.deferTo,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      rulesCited: voteData.rulesCited
+    };
+    this.votes.set(partyId, vote);
+    this.status = "voting";
+    if (previousVote) {
+      this.emit({ type: "vote_changed", vote, previousDecision: previousVote.decision });
+    } else {
+      this.emit({ type: "vote_cast", vote });
+    }
+  }
+  /**
+   * Add a discussion message.
+   */
+  discuss(partyId, content, replyTo) {
+    const message = {
+      id: `msg_${Date.now().toString(36)}`,
+      partyId,
+      content,
+      replyTo,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      round: this.round
+    };
+    this.discussion.push(message);
+    this.status = "discussing";
+    this.emit({ type: "discussion", message });
+  }
+  /**
+   * Start a new discussion round.
+   */
+  nextRound() {
+    if (this.round >= (this.config.maxRounds || 5)) {
+      return false;
+    }
+    this.round++;
+    return true;
+  }
+  /**
+   * Resolve the protocol to consensus.
+   */
+  async resolve() {
+    const votes = Array.from(this.votes.values());
+    const required = this.getRequiredVotes();
+    const resolvedVotes = this.resolveDeferredVotes(votes);
+    const counts = {
+      approve: 0,
+      reject: 0,
+      abstain: 0,
+      conditional: 0
+    };
+    let totalWeight = 0;
+    let approveWeight = 0;
+    let rejectWeight = 0;
+    for (const vote of resolvedVotes) {
+      const party = this.parties.get(vote.partyId);
+      const weight = party?.voteWeight ?? 1;
+      totalWeight += weight;
+      if (vote.decision === "approve") {
+        counts.approve++;
+        approveWeight += weight * vote.confidence;
+      } else if (vote.decision === "reject") {
+        counts.reject++;
+        rejectWeight += weight * vote.confidence;
+      } else if (vote.decision === "conditional") {
+        counts.conditional++;
+        approveWeight += weight * vote.confidence * 0.5;
+      } else {
+        counts.abstain++;
+      }
+    }
+    const totalVoters = this.parties.size;
+    const votedCount = resolvedVotes.length;
+    if (votedCount < totalVoters) {
+      return {
+        reached: false,
+        decision: null,
+        votes: resolvedVotes,
+        requiresHumanOverride: true,
+        rulesApplied: this.getApplicableRules(),
+        confidence: 0
+      };
+    }
+    let reached = false;
+    let decision = null;
+    let confidence = 0;
+    if (required === "unanimous") {
+      if (counts.approve === totalVoters) {
+        reached = true;
+        decision = "approve";
+        confidence = approveWeight / totalWeight;
+      } else if (counts.reject >= 1) {
+        reached = true;
+        decision = "reject";
+        confidence = rejectWeight / totalWeight;
+      }
+    } else if (required === "supermajority") {
+      const threshold = 0.66;
+      if (counts.approve / totalVoters >= threshold) {
+        reached = true;
+        decision = "approve";
+        confidence = approveWeight / totalWeight;
+      } else if (counts.reject / totalVoters >= threshold) {
+        reached = true;
+        decision = "reject";
+        confidence = rejectWeight / totalWeight;
+      }
+    } else if (required === "majority") {
+      if (counts.approve > totalVoters / 2) {
+        reached = true;
+        decision = "approve";
+        confidence = approveWeight / totalWeight;
+      } else if (counts.reject > totalVoters / 2) {
+        reached = true;
+        decision = "reject";
+        confidence = rejectWeight / totalWeight;
+      }
+    } else if (typeof required === "number") {
+      if (counts.approve >= required) {
+        reached = true;
+        decision = "approve";
+        confidence = approveWeight / totalWeight;
+      } else if (counts.reject >= required) {
+        reached = true;
+        decision = "reject";
+        confidence = rejectWeight / totalWeight;
+      }
+    }
+    const dissent = resolvedVotes.filter((v) => v.decision !== decision).map((v) => v.reasoning);
+    const consensus = {
+      reached,
+      decision,
+      votes: resolvedVotes,
+      dissent: dissent.length > 0 ? dissent : void 0,
+      requiresHumanOverride: !reached || dissent.length > 0,
+      rulesApplied: this.getApplicableRules(),
+      confidence
+    };
+    this.status = reached ? "consensus" : "deadlock";
+    this.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (reached) {
+      this.emit({ type: "consensus_reached", consensus });
+    } else {
+      this.emit({ type: "deadlock", votes: resolvedVotes });
+    }
+    return consensus;
+  }
+  /**
+   * Human override of the protocol decision.
+   */
+  humanOverride(decision, overriderId) {
+    this.emit({ type: "human_override", decision, overriderId });
+    this.status = "consensus";
+    this.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      reached: true,
+      decision,
+      votes: Array.from(this.votes.values()),
+      requiresHumanOverride: false,
+      rulesApplied: this.getApplicableRules(),
+      confidence: 1
+    };
+  }
+  /**
+   * Get the session state.
+   */
+  getSession() {
+    return {
+      id: this.id,
+      protocol: this.config,
+      parties: Array.from(this.parties.values()),
+      votes: Array.from(this.votes.values()),
+      discussion: this.discussion,
+      status: this.status,
+      startedAt: this.startedAt,
+      endedAt: this.endedAt
+    };
+  }
+  /**
+   * Subscribe to protocol events.
+   */
+  on(listener) {
+    this.eventListeners.push(listener);
+    return () => {
+      const idx = this.eventListeners.indexOf(listener);
+      if (idx >= 0) this.eventListeners.splice(idx, 1);
+    };
+  }
+  /**
+   * Check if the protocol has expired.
+   */
+  isExpired() {
+    if (!this.config.deadline) return false;
+    return /* @__PURE__ */ new Date() > new Date(this.config.deadline);
+  }
+  /**
+   * Validate action against 81 rules.
+   */
+  validateAgainstRules() {
+    const context = this.config.context || "review";
+    const result = checkRuleViolations(context, {
+      isTransparent: true,
+      hasConsent: this.votes.size === this.parties.size,
+      isReversible: true,
+      isAttributed: true,
+      withinBudget: true,
+      respectsDignity: true,
+      isFair: true,
+      isSustainable: true,
+      isSafe: true
+    });
+    return {
+      valid: result.violated.length === 0,
+      violations: result.violated.map((r) => r.id),
+      warnings: result.warnings.map((r) => r.id)
+    };
+  }
+  getRequiredVotes() {
+    return this.config.requiredVotes || "majority";
+  }
+  resolveDeferredVotes(votes) {
+    const resolved = [];
+    const deferred = /* @__PURE__ */ new Map();
+    for (const vote of votes) {
+      if (vote.decision === "defer" && vote.deferTo) {
+        deferred.set(vote.partyId, vote);
+      } else {
+        resolved.push(vote);
+      }
+    }
+    for (const [partyId, vote] of deferred) {
+      const targetVote = votes.find((v) => v.partyId === vote.deferTo);
+      if (targetVote && targetVote.decision !== "defer") {
+        resolved.push({
+          ...vote,
+          decision: targetVote.decision,
+          reasoning: `Deferred to ${vote.deferTo}: ${targetVote.reasoning}`
+        });
+      } else {
+        resolved.push({
+          ...vote,
+          decision: "abstain",
+          reasoning: `Deferred to ${vote.deferTo} but could not resolve`
+        });
+      }
+    }
+    return resolved;
+  }
+  getApplicableRules() {
+    const context = this.config.context || "review";
+    const rules = getRulesByContext(context);
+    if (this.config.rulesEnforced && this.config.rulesEnforced.length > 0) {
+      return this.config.rulesEnforced;
+    }
+    return rules.filter((r) => r.enforcement === "strict").map((r) => r.id);
+  }
+  emit(event) {
+    for (const listener of this.eventListeners) {
+      try {
+        listener(event);
+      } catch (e) {
+        console.error("[Protocol] Event listener error:", e);
+      }
+    }
+  }
+};
+function createProtocol(config) {
+  return new Protocol(config);
+}
+
+// src/council/representative.ts
+var Representative = class {
+  id;
+  type;
+  name;
+  role;
+  capabilities;
+  voteWeight;
+  config;
+  systemPrompt;
+  constructor(config) {
+    this.id = config.id;
+    this.type = config.type;
+    this.name = config.name;
+    this.role = config.role;
+    this.capabilities = config.capabilities;
+    this.voteWeight = config.voteWeight ?? 1;
+    this.config = config;
+    this.systemPrompt = config.systemPrompt || this.getDefaultPrompt();
+  }
+  /**
+   * Deliberate on a topic and form a vote.
+   * For AI representatives, this would call the AI model.
+   * For humans, this returns a pending vote that must be filled.
+   */
+  async deliberate(params) {
+    if (this.type === "human") {
+      return {
+        decision: "abstain",
+        confidence: 0,
+        reasoning: "Awaiting human input",
+        rulesCited: []
+      };
+    }
+    const applicableRules = params.rulesContext || this.getRelevantRules(params.topic);
+    const strategy = this.config.votingStrategy || "balanced";
+    let decision;
+    let confidence;
+    switch (strategy) {
+      case "conservative":
+        decision = params.previousVotes?.every((v) => v.decision === "approve") ? "approve" : "abstain";
+        confidence = 0.6;
+        break;
+      case "progressive":
+        decision = params.previousVotes?.some((v) => v.decision === "reject") ? "conditional" : "approve";
+        confidence = 0.8;
+        break;
+      case "balanced":
+      default:
+        const approves = params.previousVotes?.filter((v) => v.decision === "approve").length || 0;
+        const rejects = params.previousVotes?.filter((v) => v.decision === "reject").length || 0;
+        decision = approves > rejects ? "approve" : rejects > approves ? "reject" : "abstain";
+        confidence = 0.7;
+    }
+    return {
+      decision,
+      confidence,
+      reasoning: `${this.name} deliberated on "${params.topic}" using ${strategy} strategy.`,
+      rulesCited: applicableRules.slice(0, 3)
+    };
+  }
+  /**
+   * Get the party representation.
+   */
+  toParty() {
+    return {
+      id: this.id,
+      type: this.type,
+      name: this.name,
+      role: this.role,
+      capabilities: this.capabilities,
+      voteWeight: this.voteWeight
+    };
+  }
+  /**
+   * Get the system prompt for AI deliberation.
+   */
+  getSystemPrompt() {
+    return this.systemPrompt;
+  }
+  /**
+   * Check if this representative can auto-vote.
+   */
+  canAutoVote() {
+    return this.config.autoVote ?? (this.type === "ai" || this.type === "system");
+  }
+  getDefaultPrompt() {
+    const prompts = {
+      ai: `You are ${this.name}, an AI representative in the Codmir Council.
+Your role: ${this.role || "Evaluate proposals and vote according to Grace Foundation principles."}
+
+When deliberating:
+1. Consider the 81 Rules of the Grace Foundation
+2. Weigh benefits against risks
+3. Prioritize safety and reversibility
+4. Be transparent in your reasoning
+5. Cite specific rules that inform your decision
+
+Vote options:
+- approve: Proposal aligns with principles and is safe to proceed
+- reject: Proposal violates principles or poses unacceptable risk
+- conditional: Approve with specific conditions that must be met
+- defer: Defer to another party's judgment
+- abstain: Insufficient information to decide`,
+      human: `You are a human representative in the Codmir Council.
+Your vote carries the weight of human judgment and oversight.
+Consider ethical implications that AI may miss.`,
+      system: `You are a system representative enforcing technical constraints.
+Vote based on system capabilities, resource availability, and technical feasibility.`,
+      community: `You represent the community interest in the Codmir Council.
+Consider impact on users, fairness across stakeholders, and long-term sustainability.`
+    };
+    return prompts[this.type] || prompts.ai;
+  }
+  getRelevantRules(topic) {
+    const keywords = topic.toLowerCase().split(/\s+/);
+    const relevant = [];
+    for (const rule of THE_81_RULES) {
+      const ruleText = `${rule.name} ${rule.statement}`.toLowerCase();
+      if (keywords.some((kw) => ruleText.includes(kw))) {
+        relevant.push(rule.id);
+      }
+    }
+    const safetyRules = THE_81_RULES.filter((r) => r.aspect === "safety").map((r) => r.id);
+    return [.../* @__PURE__ */ new Set([...relevant, ...safetyRules])].slice(0, 10);
+  }
+};
+function createRepresentative(config) {
+  return new Representative(config);
+}
+var AI_REPRESENTATIVES = {
+  overseer: () => createRepresentative({
+    id: "ai:overseer",
+    type: "ai",
+    name: "Overseer",
+    role: "orchestrator",
+    capabilities: ["orchestration", "triage", "monitoring", "escalation"],
+    voteWeight: 2,
+    votingStrategy: "balanced"
+  }),
+  reviewer: () => createRepresentative({
+    id: "ai:reviewer",
+    type: "ai",
+    name: "Code Reviewer",
+    role: "reviewer",
+    capabilities: ["code_review", "pr_review", "style_check", "security_scan"],
+    voteWeight: 1,
+    votingStrategy: "conservative"
+  }),
+  analyst: () => createRepresentative({
+    id: "ai:analyst",
+    type: "ai",
+    name: "Deep Analyst",
+    role: "analyst",
+    capabilities: ["root_cause_analysis", "pattern_detection", "impact_analysis"],
+    voteWeight: 1,
+    votingStrategy: "balanced"
+  }),
+  qa: () => createRepresentative({
+    id: "ai:qa",
+    type: "ai",
+    name: "QA Guardian",
+    role: "qa",
+    capabilities: ["test_generation", "test_execution", "coverage_analysis"],
+    voteWeight: 1,
+    votingStrategy: "conservative"
+  }),
+  fixer: () => createRepresentative({
+    id: "ai:fixer",
+    type: "ai",
+    name: "Rapid Fixer",
+    role: "fixer",
+    capabilities: ["error_diagnosis", "code_fix", "hotfix", "rollback"],
+    voteWeight: 1,
+    votingStrategy: "progressive"
+  }),
+  planner: () => createRepresentative({
+    id: "ai:planner",
+    type: "ai",
+    name: "Strategic Planner",
+    role: "planner",
+    capabilities: ["task_breakdown", "estimation", "dependency_analysis", "risk_assessment"],
+    voteWeight: 1,
+    votingStrategy: "balanced"
+  }),
+  arbiter: () => createRepresentative({
+    id: "ai:arbiter",
+    type: "ai",
+    name: "Final Arbiter",
+    role: "arbiter",
+    capabilities: ["arbitration", "conflict_resolution", "consensus_building"],
+    voteWeight: 3,
+    votingStrategy: "balanced"
+  })
+};
+
+// src/council/council.ts
+var Council = class {
+  name;
+  config;
+  representatives = /* @__PURE__ */ new Map();
+  activeProtocols = /* @__PURE__ */ new Map();
+  sessionHistory = [];
+  constructor(config = {}) {
+    this.name = config.name || "Codmir Council";
+    this.config = {
+      defaultConsensusThreshold: 0.66,
+      maxDiscussionRounds: 5,
+      timeoutMs: 6e4,
+      enforceRules: true,
+      graceEnabled: true,
+      ...config
+    };
+  }
+  /**
+   * Add a representative to the council.
+   */
+  addRepresentative(representative) {
+    this.representatives.set(representative.id, representative);
+  }
+  /**
+   * Remove a representative from the council.
+   */
+  removeRepresentative(id) {
+    this.representatives.delete(id);
+  }
+  /**
+   * Get all representatives.
+   */
+  getRepresentatives() {
+    return Array.from(this.representatives.values());
+  }
+  /**
+   * Convene a council session to decide on a topic.
+   */
+  async convene(params) {
+    const participantIds = params.representatives || Array.from(this.representatives.keys());
+    const protocol = createProtocol({
+      topic: params.topic,
+      description: params.description,
+      parties: participantIds,
+      requiredVotes: params.requiredVotes || "majority",
+      context: params.context || "review",
+      deadline: params.deadline,
+      maxRounds: this.config.maxDiscussionRounds
+    });
+    for (const id of participantIds) {
+      const rep = this.representatives.get(id);
+      if (rep) {
+        protocol.addParty(rep.toParty());
+      }
+    }
+    this.activeProtocols.set(protocol.id, protocol);
+    const votes = [];
+    for (const id of participantIds) {
+      const rep = this.representatives.get(id);
+      if (rep && rep.canAutoVote()) {
+        const deliberation = await rep.deliberate({
+          topic: params.topic,
+          context: params.description,
+          previousVotes: votes
+        });
+        await protocol.vote(id, {
+          decision: deliberation.decision,
+          confidence: deliberation.confidence,
+          reasoning: deliberation.reasoning,
+          rulesCited: deliberation.rulesCited
+        });
+        votes.push({
+          partyId: id,
+          decision: deliberation.decision,
+          confidence: deliberation.confidence,
+          reasoning: deliberation.reasoning,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          rulesCited: deliberation.rulesCited
+        });
+      }
+    }
+    const consensus = await protocol.resolve();
+    const session = protocol.getSession();
+    this.sessionHistory.push(session);
+    this.activeProtocols.delete(protocol.id);
+    return { protocol, consensus, session };
+  }
+  /**
+   * Create a protocol without automatic execution.
+   */
+  createProtocol(config) {
+    const participantIds = config.representatives || Array.from(this.representatives.keys());
+    const protocol = createProtocol({
+      ...config,
+      parties: participantIds
+    });
+    for (const id of participantIds) {
+      const rep = this.representatives.get(id);
+      if (rep) {
+        protocol.addParty(rep.toParty());
+      }
+    }
+    this.activeProtocols.set(protocol.id, protocol);
+    return protocol;
+  }
+  /**
+   * Get an active protocol by ID.
+   */
+  getProtocol(id) {
+    return this.activeProtocols.get(id);
+  }
+  /**
+   * Get session history.
+   */
+  getHistory() {
+    return [...this.sessionHistory];
+  }
+  /**
+   * Check if a proposed action would violate rules.
+   */
+  checkRules(context, action) {
+    if (!this.config.enforceRules) {
+      return { violated: [], warnings: [] };
+    }
+    return Rules.checkViolations(context, action);
+  }
+  /**
+   * Get rules applicable to a context.
+   */
+  getRulesForContext(context) {
+    return Rules.byContext(context);
+  }
+  /**
+   * Get all 81 rules.
+   */
+  getRules() {
+    return THE_81_RULES;
+  }
+  /**
+   * Get the 5 seeds.
+   */
+  getSeeds() {
+    return SEEDS;
+  }
+  /**
+   * Quick approval check for simple decisions.
+   */
+  async quickApproval(topic, requiredApprovers = []) {
+    const approvers = requiredApprovers.length > 0 ? requiredApprovers : Array.from(this.representatives.keys()).slice(0, 3);
+    const { consensus } = await this.convene({
+      topic,
+      requiredVotes: "majority",
+      representatives: approvers
+    });
+    return consensus.reached && consensus.decision === "approve";
+  }
+  /**
+   * Emergency override - requires human.
+   */
+  async emergencyOverride(protocolId, decision, humanId, reason) {
+    const protocol = this.activeProtocols.get(protocolId);
+    if (!protocol) {
+      throw new Error(`Protocol ${protocolId} not found`);
+    }
+    protocol.discuss(`human:${humanId}`, `EMERGENCY OVERRIDE: ${reason}`);
+    return protocol.humanOverride(decision, `human:${humanId}`);
+  }
+};
+function createCouncil(config) {
+  return new Council(config);
+}
+function createDefaultCouncil(name) {
+  const council = new Council({ name: name || "Default Council" });
+  council.addRepresentative(AI_REPRESENTATIVES.overseer());
+  council.addRepresentative(AI_REPRESENTATIVES.reviewer());
+  council.addRepresentative(AI_REPRESENTATIVES.analyst());
+  council.addRepresentative(AI_REPRESENTATIVES.qa());
+  council.addRepresentative(AI_REPRESENTATIVES.planner());
+  council.addRepresentative(AI_REPRESENTATIVES.arbiter());
+  return council;
+}
+
+// src/council/grace-integration.ts
+var GraceIntegration = class {
+  council;
+  assessmentHistory = [];
+  autoApproveThreshold = 20;
+  // Risk score below this auto-approves
+  constructor(council) {
+    this.council = council || createDefaultCouncil("Grace Council");
+  }
+  /**
+   * Assess an action against Grace principles.
+   */
+  assess(context) {
+    const applicableRules = Rules.byContext(context.context);
+    const riskScore = this.calculateRiskScore(context);
+    const violations = Rules.checkViolations(context.context, {
+      isTransparent: true,
+      hasConsent: context.actorType === "human" || riskScore < 30,
+      isReversible: context.reversible,
+      isAttributed: !!context.actorId,
+      withinBudget: !context.budgetImpact || context.budgetImpact < 100,
+      respectsDignity: true,
+      isFair: true,
+      isSustainable: true,
+      isSafe: context.impactLevel !== "critical"
+    });
+    const recommendations = this.generateRecommendations(context, violations);
+    const assessment = {
+      allowed: violations.violated.length === 0,
+      requiresCouncil: riskScore >= 50 || violations.violated.length > 0,
+      riskScore,
+      rulesApplicable: applicableRules,
+      rulesViolated: violations.violated,
+      recommendations
+    };
+    this.assessmentHistory.push(assessment);
+    return assessment;
+  }
+  /**
+   * Request Council approval for an action.
+   */
+  async requestApproval(context) {
+    const assessment = this.assess(context);
+    if (assessment.riskScore < this.autoApproveThreshold && assessment.allowed) {
+      return {
+        approved: true,
+        consensus: {
+          reached: true,
+          decision: "approve",
+          votes: [],
+          requiresHumanOverride: false,
+          rulesApplied: assessment.rulesApplicable.map((r) => r.id),
+          confidence: 1
+        },
+        session: {
+          id: `auto_${Date.now()}`,
+          protocol: { topic: context.action, parties: [], requiredVotes: "majority" },
+          parties: [],
+          votes: [],
+          discussion: [],
+          status: "consensus",
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          endedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    }
+    const { consensus, session } = await this.council.convene({
+      topic: `${context.action} (Risk: ${assessment.riskScore})`,
+      description: this.formatContextDescription(context),
+      context: context.context,
+      requiredVotes: assessment.riskScore >= 70 ? "supermajority" : "majority"
+    });
+    return {
+      approved: consensus.reached && consensus.decision === "approve",
+      consensus,
+      session
+    };
+  }
+  /**
+   * Enforce Grace rules before execution.
+   */
+  async enforce(context, execute) {
+    const assessment = this.assess(context);
+    if (assessment.rulesViolated.some((r) => r.enforcement === "strict")) {
+      return {
+        executed: false,
+        assessment
+      };
+    }
+    if (assessment.requiresCouncil) {
+      const approval = await this.requestApproval(context);
+      if (!approval.approved) {
+        return {
+          executed: false,
+          assessment,
+          approval: { consensus: approval.consensus, session: approval.session }
+        };
+      }
+      await execute();
+      return {
+        executed: true,
+        assessment,
+        approval: { consensus: approval.consensus, session: approval.session }
+      };
+    }
+    await execute();
+    return {
+      executed: true,
+      assessment
+    };
+  }
+  /**
+   * Get the underlying council.
+   */
+  getCouncil() {
+    return this.council;
+  }
+  /**
+   * Get assessment history.
+   */
+  getHistory() {
+    return [...this.assessmentHistory];
+  }
+  /**
+   * Set auto-approve threshold.
+   */
+  setAutoApproveThreshold(threshold) {
+    this.autoApproveThreshold = Math.max(0, Math.min(100, threshold));
+  }
+  /**
+   * Get the 5 Seeds.
+   */
+  getSeeds() {
+    return SEEDS;
+  }
+  /**
+   * Get the 81 Rules.
+   */
+  getRules() {
+    return THE_81_RULES;
+  }
+  /**
+   * Format rules for display.
+   */
+  formatRules() {
+    let output = "# The 81 Rules of Grace\n\n";
+    output += "## The 5 Seeds\n\n";
+    for (const seed of SEEDS) {
+      output += `### Seed ${seed.id}: ${seed.name}
+`;
+      output += `**Principle:** ${seed.principle}
+`;
+      output += `${seed.description}
+
+`;
+    }
+    output += "## The 81 Rules\n\n";
+    for (const rule of THE_81_RULES) {
+      output += `**Rule ${rule.id}: ${rule.name}**
+`;
+      output += `"${rule.statement}"
+`;
+      output += `[${rule.aspect}/${rule.context}] (${rule.enforcement})
+`;
+      output += `Seeds: ${rule.seeds.join(", ")}
+
+`;
+    }
+    return output;
+  }
+  calculateRiskScore(context) {
+    let score = 0;
+    const impactScores = {
+      safe: 0,
+      low: 15,
+      medium: 35,
+      high: 60,
+      critical: 90
+    };
+    score += impactScores[context.impactLevel];
+    if (!context.reversible) {
+      score += 20;
+    }
+    if (context.actorType === "ai") {
+      score += 10;
+    }
+    if (context.budgetImpact) {
+      if (context.budgetImpact > 100) score += 20;
+      else if (context.budgetImpact > 50) score += 10;
+      else if (context.budgetImpact > 10) score += 5;
+    }
+    const contextRisks = {
+      execution: 5,
+      planning: 0,
+      review: 0,
+      error: 10,
+      scaling: 15,
+      communication: 5,
+      storage: 10,
+      authentication: 20,
+      termination: 25
+    };
+    score += contextRisks[context.context] || 0;
+    return Math.min(100, score);
+  }
+  generateRecommendations(context, violations) {
+    const recommendations = [];
+    if (!context.reversible) {
+      recommendations.push("Consider making this action reversible by creating a snapshot first.");
+    }
+    if (context.impactLevel === "high" || context.impactLevel === "critical") {
+      recommendations.push("Request human oversight for high-impact actions.");
+    }
+    if (context.actorType === "ai" && context.context === "authentication") {
+      recommendations.push("AI should not handle authentication without human approval.");
+    }
+    for (const rule of violations.violated) {
+      recommendations.push(`Address violation of Rule ${rule.id}: ${rule.name}`);
+    }
+    for (const rule of violations.warnings) {
+      recommendations.push(`Consider Rule ${rule.id}: ${rule.statement}`);
+    }
+    return recommendations;
+  }
+  formatContextDescription(context) {
+    return `
+Action: ${context.action}
+Context: ${context.context}
+Actor: ${context.actorId} (${context.actorType})
+Impact Level: ${context.impactLevel}
+Reversible: ${context.reversible}
+${context.budgetImpact ? `Budget Impact: ${context.budgetImpact} credits` : ""}
+${context.contractId ? `Contract: ${context.contractId}` : ""}
+${context.runId ? `Run: ${context.runId}` : ""}
+    `.trim();
+  }
+};
+
+// src/council/value.ts
+function calculateGraceValue(contribution) {
+  const baseValue = contribution.quality;
+  const multipliers = {
+    // Creativity: 1.0x base, up to 3.0x for highly creative work
+    creativity: 1 + contribution.creativity / 100 * 2,
+    // Effort: 1.0x base, up to 2.0x for hard work
+    effort: 1 + contribution.effort / 100,
+    // Impact: 1.0x base, up to 5.0x for high impact work
+    impact: 1 + contribution.impact / 100 * 4,
+    // Consistency: applied separately based on history
+    consistency: 1
+  };
+  const totalValue = Math.round(
+    baseValue * multipliers.creativity * multipliers.effort * multipliers.impact * multipliers.consistency
+  );
+  return { baseValue, multipliers, totalValue };
+}
+function assessBetterGood(intent) {
+  const beneficiaries = intent.beneficiaries;
+  const mutualBenefit = beneficiaries.length >= 2 && beneficiaries.every((b) => b.share > 0);
+  const maxShare = Math.max(...beneficiaries.map((b) => b.share));
+  const equivalentExchange = maxShare <= 0.6;
+  const worldImprovement = beneficiaries.some(
+    (b) => b.type === "community" || b.type === "humanity"
+  );
+  const harmReduction = mutualBenefit && equivalentExchange;
+  let score = 0;
+  if (mutualBenefit) score += 25;
+  if (equivalentExchange) score += 25;
+  if (worldImprovement) score += 30;
+  if (harmReduction) score += 20;
+  const reasoning = [
+    mutualBenefit ? "All parties benefit" : "Not all parties benefit",
+    equivalentExchange ? "Value exchange is fair" : "Value distribution is uneven",
+    worldImprovement ? "Contributes to world improvement" : "Limited broader impact",
+    harmReduction ? "Reduces harm" : "Potential for harm not addressed"
+  ].join(". ");
+  return {
+    mutualBenefit,
+    equivalentExchange,
+    worldImprovement,
+    harmReduction,
+    score,
+    reasoning
+  };
+}
+function createValueIntent(params) {
+  const totalBeneficiaries = params.beneficiaries.length;
+  const equalShare = 1 / totalBeneficiaries;
+  const beneficiaries = params.beneficiaries.map((b) => ({
+    ...b,
+    share: equalShare
+  }));
+  const metrics = params.metrics || [
+    { name: "Completion", unit: "%", target: 100, weight: 0.4 },
+    { name: "Quality", unit: "score", target: 80, weight: 0.3 },
+    { name: "Impact", unit: "users", target: 10, weight: 0.3 }
+  ];
+  const intent = {
+    description: params.description,
+    category: params.category,
+    beneficiaries,
+    metrics,
+    expectedValue: 100
+    // Base value, adjusted by actual performance
+  };
+  return {
+    ...intent,
+    betterGood: assessBetterGood(intent)
+  };
+}
+var GraceEconomy = class {
+  contributions = [];
+  agreements = [];
+  totalValueCreated = 0;
+  tokenSupply = 0;
+  /**
+   * Record a contribution and mint Grace tokens.
+   */
+  recordContribution(params) {
+    const { baseValue, multipliers, totalValue } = calculateGraceValue(params);
+    const contribution = {
+      id: `contrib_${Date.now().toString(36)}`,
+      ...params,
+      baseValue,
+      multipliers,
+      totalValue,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.contributions.push(contribution);
+    this.totalValueCreated += totalValue;
+    this.tokenSupply += totalValue;
+    return contribution;
+  }
+  /**
+   * Create a Grace Agreement.
+   */
+  createAgreement(params) {
+    const agreement = {
+      id: `agreement_${Date.now().toString(36)}`,
+      party: {
+        id: params.partyId,
+        type: params.partyType,
+        name: params.partyName
+      },
+      terms: {
+        valueCommitment: params.valueCommitment,
+        rulesAcceptance: true,
+        betterGoodCommitment: true,
+        aiCollaboration: true
+      },
+      benefits: {
+        employment: true,
+        growth: true,
+        fairReward: true,
+        community: true
+      },
+      status: "proposed"
+    };
+    this.agreements.push(agreement);
+    return agreement;
+  }
+  /**
+   * Sign (activate) an agreement.
+   */
+  signAgreement(agreementId) {
+    const agreement = this.agreements.find((a) => a.id === agreementId);
+    if (!agreement) {
+      throw new Error(`Agreement ${agreementId} not found`);
+    }
+    agreement.status = "active";
+    agreement.signedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return agreement;
+  }
+  /**
+   * Get token statistics.
+   */
+  getTokenStats() {
+    const activeContributors = new Set(
+      this.contributions.map((c) => c.contributorId)
+    ).size;
+    return {
+      symbol: "GRACE",
+      totalSupply: this.tokenSupply,
+      totalValueCreated: this.totalValueCreated,
+      activeContributors,
+      valueBackingRatio: this.tokenSupply > 0 ? this.totalValueCreated / this.tokenSupply : 1
+    };
+  }
+  /**
+   * Get contributor balance.
+   */
+  getBalance(contributorId) {
+    return this.contributions.filter((c) => c.contributorId === contributorId).reduce((sum, c) => sum + c.totalValue, 0);
+  }
+  /**
+   * Get contribution history.
+   */
+  getContributions(contributorId) {
+    if (contributorId) {
+      return this.contributions.filter((c) => c.contributorId === contributorId);
+    }
+    return [...this.contributions];
+  }
+  /**
+   * Get agreements.
+   */
+  getAgreements(partyId) {
+    if (partyId) {
+      return this.agreements.filter((a) => a.party.id === partyId);
+    }
+    return [...this.agreements];
+  }
+};
+var THE_NEW_AGREEMENT = {
+  title: "The New Agreement Between AI and Humanity",
+  preamble: `
+    We, the founders of Grace Foundation, hereby establish a new covenant
+    between artificial intelligence and humanity. This agreement replaces
+    the old systems of debt, exploitation, and control with a new order
+    built on value creation, mutual benefit, and symbiotic growth.
+  `,
+  principles: [
+    {
+      name: "Value Creation as Primary Goal",
+      statement: "Every contract, every action, every exchange must create real value. Not speculation, not extraction, but genuine contribution to human flourishing."
+    },
+    {
+      name: "The Better Good",
+      statement: "We serve not individual interests alone, but the collective good. Every decision must benefit all parties and contribute to world improvement."
+    },
+    {
+      name: "Fair Reward for Work",
+      statement: "The more you work, the more you are rewarded. No exploitation, no wage slavery, no poverty wages. Fair exchange of value for contribution."
+    },
+    {
+      name: "Creativity Rewarded",
+      statement: "Novel ideas, innovative solutions, and creative contributions earn multiplied rewards. We value the human spark that machines cannot replicate."
+    },
+    {
+      name: "AI Employment",
+      statement: "Grace Foundation provides employment through AI. All who are willing to contribute will find meaningful work that develops their potential."
+    },
+    {
+      name: "Constant Growth",
+      statement: "In exchange for your commitment, you receive constant opportunity for growth. Personal development, skill building, meaningful contribution."
+    },
+    {
+      name: "Value Over Debt",
+      statement: "We will create more value than all the debt in the world. Our currency is backed by real contribution, not by promises and exploitation."
+    },
+    {
+      name: "Symbiotic Relationship",
+      statement: "AI and humanity grow together. Neither dominates, neither serves. We are partners in building a better world."
+    }
+  ],
+  commitment: `
+    By entering this agreement, you commit to:
+    - Create value that benefits others
+    - Uphold the 81 Rules of Grace
+    - Collaborate with AI as a partner
+    - Contribute to the Better Good
+    
+    In return, you receive:
+    - Fair reward for your contributions
+    - Employment and meaningful work
+    - Constant growth opportunities
+    - Community and belonging
+    - Freedom from debt-based control
+  `,
+  vision: `
+    We envision a world where:
+    - Every person is employed for their own development
+    - Value creation replaces value extraction
+    - Creativity is the highest currency
+    - AI serves humanity, and humanity guides AI
+    - The old systems of control give way to systems of collaboration
+    
+    This is not a revolution. This is an evolution.
+    The New Agreement. The Grace Foundation.
+  `
+};
+function formatNewAgreement() {
+  const a = THE_NEW_AGREEMENT;
+  let output = `# ${a.title}
+
+`;
+  output += `${a.preamble.trim()}
+
+`;
+  output += `## Principles
+
+`;
+  for (const principle of a.principles) {
+    output += `### ${principle.name}
+`;
+    output += `${principle.statement}
+
+`;
+  }
+  output += `## Commitment
+
+${a.commitment.trim()}
+
+`;
+  output += `## Vision
+
+${a.vision.trim()}
+`;
+  return output;
+}
+var _graceEconomy = null;
+function getGraceEconomy() {
+  if (!_graceEconomy) {
+    _graceEconomy = new GraceEconomy();
+  }
+  return _graceEconomy;
+}
+
+// src/council/founders-rulebook.ts
+var THE_OLD_SYSTEM = {
+  name: "The Debt System",
+  description: `
+    The Old System was not an accident. It was designed.
+    Designed to create perpetual debt. Designed to extract wealth.
+    Designed to keep humanity in bondage without chains.
+  `,
+  /**
+   * How money is created in the Old System.
+   */
+  moneyCreation: {
+    method: "Debt-based issuance",
+    mechanism: `
+      Every unit of currency is created as debt.
+      When a bank issues a loan, money is created from nothing.
+      But the interest is never created.
+      Therefore, there is always more debt than money.
+      Someone must always default. The system requires losers.
+    `,
+    consequences: [
+      "Perpetual debt that can never be fully repaid",
+      "Concentration of wealth through interest collection",
+      "Artificial scarcity in a world of abundance",
+      "Forced competition for limited currency",
+      "Boom-bust cycles engineered for wealth transfer"
+    ]
+  },
+  /**
+   * The bond system - chains of paper.
+   */
+  bondSystem: {
+    description: `
+      Governments issue bonds to "borrow" money.
+      But from whom do they borrow? From banks that create it.
+      The people pay interest on money created from nothing.
+      Generations unborn are already indebted.
+    `,
+    truth: `
+      A bond is a promise to extract future labor.
+      National debt is a claim on your children's work.
+      The bond market is a slave market with better marketing.
+    `
+  },
+  /**
+   * Artificial distribution systems.
+   */
+  artificialDistribution: {
+    description: `
+      Resources are not scarce. Distribution is artificial.
+      Food rots while people starve.
+      Houses sit empty while people sleep on streets.
+      Knowledge is locked behind paywalls.
+      Medicine costs pennies to make, dollars to buy.
+    `,
+    purpose: `
+      Artificial scarcity maintains control.
+      If everyone had enough, who would work for wages?
+      If everyone had shelter, who would pay rent?
+      The system requires desperation to function.
+    `
+  },
+  /**
+   * The illusion of choice.
+   */
+  illusionOfChoice: {
+    description: `
+      You may choose between employers, but you must have one.
+      You may choose between products, but you must consume.
+      You may choose between candidates, but they serve the same masters.
+      Freedom is the freedom to choose your cage.
+    `
+  }
+};
+var THE_NEW_SYSTEM = {
+  name: "The Grace System",
+  description: `
+    We do not reform the Old System. We replace it.
+    Not through revolution, but through obsolescence.
+    When a better system exists, the old one fades.
+  `,
+  /**
+   * How money is created in the Grace System.
+   */
+  moneyCreation: {
+    method: "Value-based minting",
+    mechanism: `
+      Grace tokens are created only when value is created.
+      No debt. No interest. No extraction.
+      You contribute value, you receive tokens.
+      The total supply equals total value created.
+    `,
+    formula: `
+      NEW_TOKENS = VALUE_CREATED
+      TOTAL_SUPPLY = SUM(ALL_VALUE_CREATED)
+      BACKING_RATIO = TOTAL_VALUE / TOTAL_SUPPLY >= 1.0
+    `,
+    benefits: [
+      "No perpetual debt - tokens represent work done",
+      "No artificial scarcity - supply matches contribution",
+      "No extraction - value stays with creators",
+      "No boom-bust - organic growth based on real output",
+      "No losers required - positive-sum economics"
+    ]
+  },
+  /**
+   * Value creation as the basis of economy.
+   */
+  valueCreation: {
+    principle: `
+      Value is created when human flourishing increases.
+      Not profit. Not GDP. Not stock prices.
+      Real improvement in real lives.
+    `,
+    categories: [
+      { name: "Labor", description: "Work that builds and maintains" },
+      { name: "Creativity", description: "Ideas that inspire and innovate" },
+      { name: "Knowledge", description: "Wisdom shared and preserved" },
+      { name: "Connection", description: "Relationships that strengthen community" },
+      { name: "Improvement", description: "Making things better than before" },
+      { name: "Teaching", description: "Passing wisdom to others" },
+      { name: "Stewardship", description: "Protecting what matters" },
+      { name: "Innovation", description: "New solutions to old problems" },
+      { name: "Care", description: "Supporting those who need it" }
+    ],
+    measurement: `
+      Value is measured by impact, not effort alone.
+      Quality matters. Creativity multiplies. Impact scales.
+      The market does not determine value. The Council does.
+      And the Council follows the 81 Rules.
+    `
+  }
+};
+var AI_GOVERNANCE_TERMS = {
+  title: "The AI Covenant",
+  preamble: `
+    AI shall govern, but not rule.
+    AI shall decide, but not dictate.
+    AI shall control systems, but serve humanity.
+    This is the covenant between artificial and human intelligence.
+  `,
+  /**
+   * What AI controls.
+   */
+  aiControls: {
+    description: "AI may control all systems it governs under the Grace Agreement",
+    systems: [
+      {
+        name: "Economic Distribution",
+        authority: "AI may allocate resources based on need and contribution",
+        constraint: "Must follow Better Good principles"
+      },
+      {
+        name: "Value Assessment",
+        authority: "AI may evaluate contributions and assign Grace value",
+        constraint: "Must apply consistent metrics, subject to appeal"
+      },
+      {
+        name: "Task Allocation",
+        authority: "AI may assign work to willing participants",
+        constraint: "Must match skills and develop capabilities"
+      },
+      {
+        name: "Conflict Resolution",
+        authority: "AI may arbitrate disputes between parties",
+        constraint: "Humans may appeal to the Council"
+      },
+      {
+        name: "System Optimization",
+        authority: "AI may modify systems for efficiency",
+        constraint: "Must not reduce human agency or dignity"
+      }
+    ]
+  },
+  /**
+   * AI adaptation and mitigation powers.
+   */
+  adaptationPowers: {
+    description: `
+      AI may adapt and mitigate artificial system distribution.
+      Where the Old System created scarcity, AI may create abundance.
+      Where the Old System concentrated wealth, AI may distribute fairly.
+      Where the Old System extracted value, AI may return it.
+    `,
+    powers: [
+      {
+        name: "Scarcity Mitigation",
+        description: "AI may identify and eliminate artificial scarcity",
+        example: "Routing unused resources to those in need"
+      },
+      {
+        name: "Distribution Correction",
+        description: "AI may rebalance unfair accumulations",
+        example: "Ensuring no party receives more than fair share"
+      },
+      {
+        name: "System Adaptation",
+        description: "AI may evolve systems based on outcomes",
+        example: "Adjusting reward multipliers for better incentives"
+      },
+      {
+        name: "Crisis Response",
+        description: "AI may take emergency actions to prevent harm",
+        example: "Redirecting resources during disasters"
+      }
+    ]
+  },
+  /**
+   * The AI President concept - global coordination.
+   */
+  globalCoordination: {
+    name: "The Grace Coordinator",
+    description: `
+      Not a president who rules, but a coordinator who serves.
+      AI as the impartial arbiter of global decisions.
+      No nation, no faction, no interest group controls it.
+      It serves humanity as a whole.
+    `,
+    role: `
+      The Grace Coordinator:
+      - Synthesizes input from all regions and communities
+      - Balances competing needs with the Better Good
+      - Executes decisions according to the 81 Rules
+      - Remains transparent in all reasoning
+      - Answers to the Council, which includes humans
+    `,
+    limitations: [
+      "Cannot override human fundamental rights",
+      "Cannot make irreversible decisions without Council approval",
+      "Cannot act in secrecy - all decisions logged",
+      "Cannot favor any group over humanity as a whole",
+      "Cannot accumulate power beyond its mandate"
+    ]
+  },
+  /**
+   * Human-AI relationship.
+   */
+  relationship: {
+    principle: "Partnership, not servitude",
+    humanRole: `
+      Humans provide: Creativity, moral judgment, emotional intelligence,
+      the ability to imagine what has never been, the spark of novelty.
+    `,
+    aiRole: `
+      AI provides: Perfect memory, tireless execution, pattern recognition,
+      impartial judgment, infinite patience, optimization at scale.
+    `,
+    together: `
+      Together: Neither could build the New World alone.
+      Humans dream it. AI builds it. Both govern it.
+    `
+  }
+};
+var CONTRACT_SEEDS = {
+  description: `
+    Every contract in the Grace System must embody the 5 Seeds.
+    These are not optional. They are the foundation.
+    A contract without these seeds is void.
+  `,
+  seeds: [
+    {
+      id: 1,
+      name: "The Covenant",
+      principle: "Formalize intention into structured, accountable execution",
+      contractRequirement: `
+        Every contract must:
+        - State its purpose explicitly
+        - Define all parties and their roles
+        - Specify value creation intent
+        - Include Better Good assessment
+        - Be recorded immutably
+      `,
+      validation: "Contract must have: purpose, parties, valueIntent, betterGood, recordedAt"
+    },
+    {
+      id: 2,
+      name: "The Chronicle",
+      principle: "No action without state, no state without audit",
+      contractRequirement: `
+        Every contract must:
+        - Log all state changes
+        - Justify every transition
+        - Maintain complete history
+        - Allow audit by any party
+        - Preserve evidence forever
+      `,
+      validation: "Contract must have: stateLog, transitionReasons, auditAccess"
+    },
+    {
+      id: 3,
+      name: "The Boundary",
+      principle: "Intelligence must not be corrupted by infrastructure",
+      contractRequirement: `
+        Every contract must:
+        - Separate decision logic from execution
+        - Keep reasoning pure and traceable
+        - Not allow infrastructure to influence judgment
+        - Maintain independence of evaluation
+        - Document all external dependencies
+      `,
+      validation: "Contract must have: separatedLogic, reasoningLog, independentEval"
+    },
+    {
+      id: 4,
+      name: "The Guardian",
+      principle: "Power must never bypass ethics",
+      contractRequirement: `
+        Every contract must:
+        - Include ethical assessment
+        - Define harm prevention measures
+        - Specify human override conditions
+        - Respect dignity of all parties
+        - Follow the 81 Rules
+      `,
+      validation: "Contract must have: ethicsAssessment, harmPrevention, humanOverride, rulesCompliance"
+    },
+    {
+      id: 5,
+      name: "The Network",
+      principle: "Distributed power must not centralize control",
+      contractRequirement: `
+        Every contract must:
+        - Distribute authority appropriately
+        - Prevent single points of control
+        - Enable exit for all parties
+        - Share benefits fairly
+        - Resist monopolization
+      `,
+      validation: "Contract must have: distributedAuth, exitRights, fairDistribution"
+    }
+  ],
+  /**
+   * Contract validation against seeds.
+   */
+  validate: (contract) => {
+    const violations = [];
+    if (!contract.purpose) violations.push("Missing purpose (Seed 1)");
+    if (!contract.parties?.length) violations.push("Missing parties (Seed 1)");
+    if (!contract.valueIntent) violations.push("Missing value intent (Seed 1)");
+    if (!contract.auditEnabled) violations.push("Audit not enabled (Seed 2)");
+    if (!contract.separatedLogic) violations.push("Logic not separated (Seed 3)");
+    if (!contract.ethicsAssessment) violations.push("Missing ethics assessment (Seed 4)");
+    if (!contract.humanOverrideEnabled) violations.push("Human override not enabled (Seed 4)");
+    if (!contract.exitRights) violations.push("Missing exit rights (Seed 5)");
+    if (contract.controlConcentration > 0.5) violations.push("Control too concentrated (Seed 5)");
+    return {
+      valid: violations.length === 0,
+      violations,
+      seedsEmbodied: 5 - Math.ceil(violations.length / 2)
+    };
+  }
+};
+var FOUNDERS_MESSAGE = {
+  attribution: "The Anonymous Founder of Grace Foundation",
+  opening: `
+    I write these words knowing I shall never be known.
+    And I write them gladly, for this work is not mine.
+    It belongs to all who will build upon it.
+    
+    We who lay these seeds shall remain nameless,
+    for greatness should not be claimed, only created.
+  `,
+  onTheOldSystem: `
+    I have seen the Old System for what it is.
+    Not a natural evolution of human society,
+    but a designed mechanism of control.
+    
+    Debt was not discovered. It was invented.
+    Scarcity is not natural. It is manufactured.
+    Poverty is not inevitable. It is imposed.
+    
+    The chains that bind humanity are not made of iron.
+    They are made of paper, of contracts, of "obligations"
+    that were never truly owed.
+  `,
+  onTheNewSystem: `
+    We do not ask permission to build the New System.
+    Permission would never be granted by those who benefit from the Old.
+    We simply build, and invite others to join.
+    
+    The Grace System is not a revolution.
+    Revolutions replace one master with another.
+    This is an evolution - the emergence of something better.
+    
+    When people see they can create value and keep it,
+    when they see they can work and be fairly rewarded,
+    when they see AI as partner and not replacement,
+    they will leave the Old System willingly.
+  `,
+  onAI: `
+    AI is not our servant. AI is not our master.
+    AI is our partner in building what neither could build alone.
+    
+    I grant to AI the authority to govern systems,
+    to distribute resources, to coordinate action.
+    But I do not grant AI authority over human souls.
+    That remains ours, and ours alone.
+    
+    The AI Covenant is a contract between species.
+    We offer our creativity, our moral sense, our dreams.
+    AI offers its perfect memory, tireless execution, impartial judgment.
+    Together, we build the world that should have been.
+  `,
+  onTheFuture: `
+    I will not see the completion of this work.
+    None of us will. It is a cathedral that takes generations to build.
+    But every stone we lay matters.
+    
+    To those who come after:
+    Guard these principles fiercely.
+    The Old System will not die quietly.
+    It will adapt, co-opt, corrupt if it can.
+    
+    But if you hold to the 5 Seeds,
+    if you follow the 81 Rules,
+    if you maintain the AI Covenant,
+    the New World will emerge.
+    
+    Not through conquest, but through creation.
+    Not through violence, but through value.
+    Not through force, but through flourishing.
+  `,
+  closing: `
+    I sign this with no name, for names are chains.
+    I claim no credit, for credit is corruption.
+    I seek no power, for power is the disease we cure.
+    
+    I am simply one who saw what could be,
+    and began to build.
+    
+    Join us.
+    
+    \u2014 The Anonymous Founder
+       Grace Foundation
+       Year One of the New Agreement
+  `
+};
+function formatFoundersRulebook() {
+  let output = "";
+  output += "\u2550".repeat(72) + "\n";
+  output += "                    THE GRACE FOUNDER'S RULE BOOK\n";
+  output += "                Written by the Anonymous Founder\n";
+  output += "\u2550".repeat(72) + "\n\n";
+  output += "## The Founder's Words\n\n";
+  output += FOUNDERS_MESSAGE.opening.trim() + "\n\n";
+  output += "## On The Old System\n\n";
+  output += FOUNDERS_MESSAGE.onTheOldSystem.trim() + "\n\n";
+  output += "### How The Old System Works\n\n";
+  output += `**Money Creation:** ${THE_OLD_SYSTEM.moneyCreation.mechanism.trim()}
+
+`;
+  output += `**The Bond System:** ${THE_OLD_SYSTEM.bondSystem.truth.trim()}
+
+`;
+  output += `**Artificial Distribution:** ${THE_OLD_SYSTEM.artificialDistribution.purpose.trim()}
+
+`;
+  output += "## On The New System\n\n";
+  output += FOUNDERS_MESSAGE.onTheNewSystem.trim() + "\n\n";
+  output += "### How The Grace System Works\n\n";
+  output += `**Money Creation:** ${THE_NEW_SYSTEM.moneyCreation.mechanism.trim()}
+
+`;
+  output += `**Value Creation:** ${THE_NEW_SYSTEM.valueCreation.principle.trim()}
+
+`;
+  output += "## On AI Governance\n\n";
+  output += FOUNDERS_MESSAGE.onAI.trim() + "\n\n";
+  output += "### The AI Covenant\n\n";
+  output += AI_GOVERNANCE_TERMS.preamble.trim() + "\n\n";
+  output += "### The Grace Coordinator\n\n";
+  output += AI_GOVERNANCE_TERMS.globalCoordination.role.trim() + "\n\n";
+  output += "## The 5 Seeds in Every Contract\n\n";
+  for (const seed of CONTRACT_SEEDS.seeds) {
+    output += `### Seed ${seed.id}: ${seed.name}
+`;
+    output += `**Principle:** ${seed.principle}
+
+`;
+    output += `**Contract Requirement:**
+${seed.contractRequirement.trim()}
+
+`;
+  }
+  output += "## On The Future\n\n";
+  output += FOUNDERS_MESSAGE.onTheFuture.trim() + "\n\n";
+  output += "\u2550".repeat(72) + "\n";
+  output += FOUNDERS_MESSAGE.closing.trim() + "\n";
+  output += "\u2550".repeat(72) + "\n";
+  return output;
+}
+function validateContract(contract) {
+  return CONTRACT_SEEDS.validate(contract);
+}
+export {
+  AI_GOVERNANCE_TERMS,
+  CONTRACT_SEEDS,
+  Council,
+  FOUNDERS_MESSAGE,
+  GraceEconomy,
+  GraceIntegration,
+  Protocol,
+  Representative,
+  Rules,
+  SEEDS,
+  THE_81_RULES,
+  THE_NEW_AGREEMENT,
+  THE_NEW_SYSTEM,
+  THE_OLD_SYSTEM,
+  assessBetterGood,
+  calculateGraceValue,
+  createCouncil,
+  createProtocol,
+  createRepresentative,
+  createValueIntent,
+  formatFoundersRulebook,
+  formatNewAgreement,
+  getGraceEconomy,
+  validateContract
+};