@manya-os/council 1.0.0

package/dist/types/router/router.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @manya-os/council — specialist routing.
+ *
+ * The router matches a {@link Problem} against a pool of {@link Specialist}s
+ * by computing a Jaccard-style token-overlap score between the problem's
+ * description+domain and each specialist's `expertise` tags. The free
+ * function `route(problem, specialists)` returns the specialists with
+ * positive match scores, sorted best-first; `routeAll` returns every
+ * specialist along with its score.
+ *
+ * The {@link SpecialistRegistry} is a stateful convenience wrapper that owns a
+ * pool of specialists and exposes `route(problem)` / `routeAll(problem)`.
+ *
+ * Copyright 2024 Manya Hael Foundation. All rights reserved.
+ * Licensed under the Apache License, Version 2.0.
+ */
+import type { Problem, Specialist } from '../types.js';
+/** A specialist paired with its match score against a problem. */
+export interface SpecialistMatch {
+    /** The specialist. */
+    specialist: Specialist;
+    /** Match score in `[0, 1]`. `0` means no overlap. */
+    score: number;
+}
+/**
+ * Validates a specialist structurally. Throws `RoutingError` on invalid fields.
+ */
+export declare function validateSpecialist(specialist: Specialist): void;
+/**
+ * Computes a match score for `problem` against `specialist`. The score is the
+ * Jaccard similarity between the problem's description+domain tokens and the
+ * specialist's expertise tokens. Returns `0` when either side has no tokens.
+ */
+export declare function matchScore(problem: Problem, specialist: Specialist): number;
+/**
+ * Returns the ranked list of specialists with positive match scores against
+ * `problem`, sorted best-first. Specialists with no overlap are excluded.
+ * Ties are broken by descending `weight`, then by registration order.
+ */
+export declare function route(problem: Problem, specialists: Specialist[]): Specialist[];
+/**
+ * Returns every specialist paired with its match score, sorted best-first.
+ * Includes specialists with a score of `0`.
+ */
+export declare function routeAll(problem: Problem, specialists: Specialist[]): SpecialistMatch[];
+/**
+ * Stateful registry of specialists. Callers `register` specialists, then use
+ * `route(problem)` to get the ranked list, or `routeAll(problem)` to get the
+ * ranked list with scores.
+ *
+ * Usage:
+ * ```ts
+ * const registry = new SpecialistRegistry()
+ *   .register({ id: 'sec', name: 'Security', expertise: ['security', 'crypto'], weight: 1 })
+ *   .register({ id: 'fin', name: 'Finance', expertise: ['finance', 'audit'], weight: 1 });
+ * const ranked = registry.route({ id: 'p1', description: 'audit the crypto', domain: 'security', createdAt: '' });
+ * // ranked = [sec, fin] (sec scores higher on 'crypto'/'security')
+ * ```
+ */
+export declare class SpecialistRegistry {
+    private readonly specialists;
+    private readonly order;
+    /** Registers a specialist. Throws `RoutingError` on duplicate id or invalid fields. */
+    register(specialist: Specialist): this;
+    /** Removes a specialist by id. No-op if not found. */
+    unregister(id: string): this;
+    /** Returns the specialist with the given id, or `undefined`. */
+    get(id: string): Specialist | undefined;
+    /** Returns all registered specialists in insertion order. */
+    list(): Specialist[];
+    /** Returns the ranked list of specialists with positive match scores. */
+    route(problem: Problem): Specialist[];
+    /** Returns every specialist with its match score, sorted best-first. */
+    routeAll(problem: Problem): SpecialistMatch[];
+}
+//# sourceMappingURL=router.d.ts.map

package/dist/types/router/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../../src/router/router.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAIvD,kEAAkE;AAClE,MAAM,WAAW,eAAe;IAC9B,sBAAsB;IACtB,UAAU,EAAE,UAAU,CAAC;IACvB,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAqB/D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM,CAkB3E;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAkB/E;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,eAAe,EAAE,CAiBvF;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiC;IAC7D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IAEtC,uFAAuF;IACvF,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAUtC,sDAAsD;IACtD,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAO5B,gEAAgE;IAChE,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAIvC,6DAA6D;IAC7D,IAAI,IAAI,UAAU,EAAE;IAIpB,yEAAyE;IACzE,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,EAAE;IAIrC,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,eAAe,EAAE;CAG9C"}

package/dist/types/scoring/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @manya-os/council — scoring barrel.
+ *
+ * Copyright 2024 Manya Hael Foundation. All rights reserved.
+ * Licensed under the Apache License, Version 2.0.
+ */
+export { scoreAnalysis, aggregateScores, detectOutliers, DEFAULT_OUTLIER_THRESHOLD, } from './scoring.js';
+export type { WeightedScore, AggregatedScore } from './scoring.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/scoring/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/scoring/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,aAAa,EAAE,eAAe,EAAE,cAAc,EAAE,yBAAyB,GAC1E,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}

package/dist/types/scoring/scoring.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @manya-os/council — weighted confidence scoring.
+ *
+ * Provides three free functions:
+ *
+ *   - `scoreAnalysis(analysis, specialistWeight)` returns a single weighted
+ *     score (`confidence × weight`).
+ *   - `aggregateScores(analyses, weights)` returns the weighted mean of all
+ *     confidences plus the variance and standard deviation of the raw
+ *     confidences (so callers can gauge dispersion).
+ *   - `detectOutliers(analyses, threshold)` returns analyses whose confidence
+ *     deviates from the median by more than `threshold`.
+ *
+ * Copyright 2024 Manya Hael Foundation. All rights reserved.
+ * Licensed under the Apache License, Version 2.0.
+ */
+import type { Analysis } from '../types.js';
+/** A single weighted score. */
+export interface WeightedScore {
+    /** Id of the analysis this score is for. */
+    analysisId: string;
+    /** Raw confidence from the analysis. */
+    raw: number;
+    /** Specialist weight applied. */
+    weight: number;
+    /** `raw × weight`. */
+    weighted: number;
+}
+/** Result of `aggregateScores`: combined confidence plus dispersion. */
+export interface AggregatedScore {
+    /** Weighted mean of confidences (`Σ confidence×weight / Σ weight`). */
+    combined: number;
+    /** Variance of the raw confidences (population variance). */
+    variance: number;
+    /** Standard deviation of the raw confidences. */
+    stddev: number;
+    /** Number of analyses aggregated. */
+    total: number;
+    /** Per-analysis weighted scores (`confidence×weight`), in input order. */
+    weighted: number[];
+}
+/** Default outlier deviation threshold. */
+export declare const DEFAULT_OUTLIER_THRESHOLD = 0.25;
+/**
+ * Returns a single weighted score: `analysis.confidence × specialistWeight`.
+ * Throws `ScoringError` when either input is invalid.
+ */
+export declare function scoreAnalysis(analysis: Analysis, specialistWeight: number): WeightedScore;
+/**
+ * Aggregates a set of analyses into a combined confidence and dispersion
+ * statistics. `weights` is a map of `specialistId → weight`. Throws
+ * `ScoringError` when a specialist's weight is missing or invalid.
+ *
+ * Returns `{ combined: 0, variance: 0, stddev: 0, total: 0, weighted: [] }`
+ * when `analyses` is empty.
+ */
+export declare function aggregateScores(analyses: Analysis[], weights: Record<string, number>): AggregatedScore;
+/**
+ * Returns analyses whose confidence deviates from the median by more than
+ * `threshold` (absolute difference). Returns `[]` when fewer than two
+ * analyses are provided. The default threshold is
+ * {@link DEFAULT_OUTLIER_THRESHOLD}.
+ */
+export declare function detectOutliers(analyses: Analysis[], threshold?: number): Analysis[];
+//# sourceMappingURL=scoring.d.ts.map

package/dist/types/scoring/scoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoring.d.ts","sourceRoot":"","sources":["../../../src/scoring/scoring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAG5C,+BAA+B;AAC/B,MAAM,WAAW,aAAa;IAC5B,4CAA4C;IAC5C,UAAU,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,sBAAsB;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,wEAAwE;AACxE,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,2CAA2C;AAC3C,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAuB9C;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,GAAG,aAAa,CAWzF;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,QAAQ,EAAE,EACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,eAAe,CAiCjB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,QAAQ,EAAE,EACpB,SAAS,GAAE,MAAkC,GAC5C,QAAQ,EAAE,CAaZ"}

package/dist/types/synthesizer/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @manya-os/council — synthesizer barrel.
+ *
+ * Copyright 2024 Manya Hael Foundation. All rights reserved.
+ * Licensed under the Apache License, Version 2.0.
+ */
+export { synthesize, classifyConsensus, DEFAULT_SYNTHESIS_THRESHOLD, STRONG_CONSENSUS_RATIO, } from './synthesizer.js';
+export type { SynthesizeOptions } from './synthesizer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/synthesizer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/synthesizer/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,UAAU,EAAE,iBAAiB,EAC7B,2BAA2B,EAAE,sBAAsB,GACpD,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/types/synthesizer/synthesizer.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @manya-os/council — final decision synthesis.
+ *
+ * The {@link synthesize} function takes the {@link Consensus} (if any), the
+ * underlying analyses, the detected conflicts, and (optionally) the recorded
+ * minority opinions, and produces a {@link Decision} with an explicit
+ * confidence and rationale. The decision's `consensusLevel` summarizes the
+ * strength of the consensus:
+ *
+ *   - `'unanimous'` — no dissent at all,
+ *   - `'strong'`    — weighted support ≥ 0.8,
+ *   - `'majority'`  — weighted support ≥ the threshold (default 0.6),
+ *   - `'split'`     — consensus exists but support is weak (below threshold),
+ *   - `'none'`      — no consensus was reached.
+ *
+ * Copyright 2024 Manya Hael Foundation. All rights reserved.
+ * Licensed under the Apache License, Version 2.0.
+ */
+import type { Analysis, Conflict, Consensus, ConsensusLevel, Decision, MinorityOpinion } from '../types.js';
+/** Default threshold for distinguishing `'majority'` from `'split'`. */
+export declare const DEFAULT_SYNTHESIS_THRESHOLD = 0.6;
+/** Strong-consensus threshold (support ratio at or above this is `'strong'`). */
+export declare const STRONG_CONSENSUS_RATIO = 0.8;
+/** Options accepted by `synthesize`. */
+export interface SynthesizeOptions {
+    /** Recorded minority opinions to fold into the rationale. */
+    minorityOpinions?: MinorityOpinion[];
+    /** Override the consensus-threshold for level classification. */
+    threshold?: number;
+    /** Override the generated decision id. */
+    decisionId?: string;
+    /** Override the generated-at timestamp (ISO 8601). */
+    generatedAt?: string;
+    /** Override the decision text (defaults to the consensus decision, or a no-consensus fallback). */
+    decision?: string;
+}
+/**
+ * Computes the {@link ConsensusLevel} for the given consensus and analyses.
+ * Returns `'none'` when `consensus` is `null`.
+ */
+export declare function classifyConsensus(consensus: Consensus | null, threshold?: number): ConsensusLevel;
+/**
+ * Synthesizes a {@link Decision} from the consensus, analyses, conflicts, and
+ * (optionally) minority opinions. Throws `SynthesisError` on invalid inputs.
+ *
+ * Usage:
+ * ```ts
+ * const decision = synthesize('p1', consensus, analyses, conflicts, {
+ *   minorityOpinions: tracker.getForProblem('p1'),
+ * });
+ * ```
+ */
+export declare function synthesize(problemId: string, consensus: Consensus | null, analyses: Analysis[], conflicts?: Conflict[], options?: SynthesizeOptions): Decision;
+//# sourceMappingURL=synthesizer.d.ts.map

package/dist/types/synthesizer/synthesizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synthesizer.d.ts","sourceRoot":"","sources":["../../../src/synthesizer/synthesizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EACV,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,eAAe,EACzE,MAAM,aAAa,CAAC;AAGrB,wEAAwE;AACxE,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAE/C,iFAAiF;AACjF,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,wCAAwC;AACxC,MAAM,WAAW,iBAAiB;IAChC,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAC;IACrC,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mGAAmG;IACnG,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,SAAS,GAAG,IAAI,EAC3B,SAAS,GAAE,MAAoC,GAC9C,cAAc,CAMhB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CACxB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,SAAS,GAAG,IAAI,EAC3B,QAAQ,EAAE,QAAQ,EAAE,EACpB,SAAS,GAAE,QAAQ,EAAO,EAC1B,OAAO,GAAE,iBAAsB,GAC9B,QAAQ,CA2EV"}

package/dist/types/types.d.ts

@@ -0,0 +1,246 @@
+/**
+ * @manya-os/council — shared type definitions.
+ *
+ * All cross-module type definitions live here so that modules can import the
+ * shape they need without circular dependencies. Per-module "value" interfaces
+ * (e.g. `Specialist`, `Analysis`, `Consensus`) are declared here for symmetry
+ * with other MANYA packages and to keep the public surface discoverable.
+ *
+ * Copyright 2024 Manya Hael Foundation. All rights reserved.
+ * Licensed under the Apache License, Version 2.0.
+ */
+import type { Logger, LogLevel } from './logging.js';
+/**
+ * A problem under consideration by the council.
+ *
+ * The `domain` field is a free-form tag (e.g. `'security'`, `'finance'`) used
+ * by the {@link SpecialistRegistry} to route the problem to specialists whose
+ * `expertise` overlaps with the domain and the description tokens.
+ */
+export interface Problem {
+    /** Stable, unique problem id. */
+    id: string;
+    /** Human-readable description of the problem. */
+    description: string;
+    /** Free-form domain tag (e.g. `'security'`, `'finance'`). */
+    domain: string;
+    /** Optional structured context (e.g. payloads, metadata). */
+    context?: Record<string, unknown>;
+    /** ISO 8601 timestamp of when the problem was posed. */
+    createdAt: string;
+}
+/**
+ * A specialist agent that may be routed a problem.
+ *
+ * `weight` is a non-negative number that influences how much this specialist's
+ * confidence contributes to aggregated scores and consensus. Higher weight
+ * means more influence. `reputation` is optional and may be used by callers to
+ * seed `weight` from historical performance.
+ */
+export interface Specialist {
+    /** Stable, unique specialist id. */
+    id: string;
+    /** Human-readable name. */
+    name: string;
+    /** Areas of expertise (free-form tags/keywords). */
+    expertise: string[];
+    /** Non-negative influence weight used by the scoring module. */
+    weight: number;
+    /** Optional reputation score (e.g. 0..1). Not used internally. */
+    reputation?: number;
+}
+/**
+ * An independent analysis produced by a specialist for a problem.
+ *
+ * `confidence` is a number in `[0, 1]`. The `content` is the specialist's
+ * conclusion (used by the conflict detector to infer a polarity — `'positive'`
+ * vs `'negative'` stance — via simple keyword matching). `reasoning` is the
+ * chain of reasoning, and `caveats` is an optional list of reservations.
+ */
+export interface Analysis {
+    /** Stable, unique analysis id. */
+    id: string;
+    /** Id of the specialist who produced this analysis. */
+    specialistId: string;
+    /** Id of the problem this analysis addresses. */
+    problemId: string;
+    /** The specialist's conclusion (e.g. "I recommend we adopt the proposal."). */
+    content: string;
+    /** Confidence in the conclusion, in `[0, 1]`. */
+    confidence: number;
+    /** The chain of reasoning supporting the conclusion. */
+    reasoning: string;
+    /** Optional reservations or limitations. */
+    caveats?: string[];
+}
+/** Severity of a detected conflict. */
+export type ConflictSeverity = 'low' | 'medium' | 'high';
+/**
+ * The kind of disagreement detected between two or more analyses.
+ *
+ * - `opposing_conclusion`  — high-confidence analyses on opposite sides of an
+ *   issue (one positive, one negative, both > 0.6 confidence).
+ * - `factual_contradiction` — analyses that overlap substantially in subject
+ *   matter but reach opposite polarities, suggesting a factual dispute.
+ * - `divergent_reasoning`  — analyses that reach the same polarity but via
+ *   very different reasoning paths, suggesting an unstated disagreement.
+ */
+export type ConflictType = 'opposing_conclusion' | 'factual_contradiction' | 'divergent_reasoning';
+/** A conflict between two or more analyses. */
+export interface Conflict {
+    /** Stable, unique conflict id. */
+    id: string;
+    /** The problem the conflict pertains to. */
+    problemId: string;
+    /** Ids of the analyses involved in the conflict. */
+    analysisIds: string[];
+    /** Human-readable description of the conflict. */
+    description: string;
+    /** Severity, based on the number of analyses involved and the confidence gap. */
+    severity: ConflictSeverity;
+    /** The kind of conflict. */
+    type: ConflictType;
+}
+/** Lifecycle status of a debate. */
+export type DebateStatus = 'open' | 'concluded';
+/** A single round of a structured debate. */
+export interface DebateRound {
+    /** Stable, unique round id (within the debate). */
+    id: string;
+    /** Id of the analyst (typically a specialist) submitting the round. */
+    analystId: string;
+    /** The claim being made in this round. */
+    claim: string;
+    /** Evidence supporting the claim. */
+    evidence: string;
+    /** Optional id of the round this round rebuts. */
+    rebuttalTo?: string;
+}
+/** A structured debate over one or more conflicts. */
+export interface Debate {
+    /** Stable, unique debate id. */
+    id: string;
+    /** The problem the debate pertains to. */
+    problemId: string;
+    /** Conflict ids that triggered this debate. */
+    conflictIds: string[];
+    /** Ordered list of debate rounds. */
+    rounds: DebateRound[];
+    /** Current status of the debate. */
+    status: DebateStatus;
+    /** ISO 8601 timestamp when the debate was opened. */
+    openedAt: string;
+    /** ISO 8601 timestamp when the debate was concluded, if any. */
+    concludedAt?: string;
+}
+/**
+ * A minority opinion — a dissenting position recorded separately from the
+ * consensus decision. Minority opinions preserve dissent for audit and future
+ * reconsideration.
+ */
+export interface MinorityOpinion {
+    /** Stable, unique opinion id. */
+    id: string;
+    /** The problem the opinion pertains to. */
+    problemId: string;
+    /** Id of the analyst recording the opinion. */
+    analystId: string;
+    /** The dissenting position. */
+    position: string;
+    /** The reasoning supporting the position. */
+    reasoning: string;
+    /** Why this analyst dissents from the consensus. */
+    dissentReason: string;
+}
+/**
+ * A consensus decision. Built by the consensus builder from a set of analyses
+ * and any detected conflicts. When consensus is not reached (weighted support
+ * below the threshold), the builder returns `null` instead.
+ */
+export interface Consensus {
+    /** The problem the consensus pertains to. */
+    problemId: string;
+    /** The decision text. */
+    decision: string;
+    /** The weighted support ratio, in `[0, 1]`. */
+    confidence: number;
+    /** Ids of specialists whose analyses support the decision. */
+    supportingAnalystIds: string[];
+    /** Ids of specialists whose analyses dissent from the decision. */
+    dissentingAnalystIds: string[];
+    /** Ids of conflicts that were considered (resolved or otherwise). */
+    conflictsResolved: string[];
+    /** Unresolved high-severity issues that the caller should address. */
+    openIssues: string[];
+}
+/**
+ * A full review report aggregating analyses, conflicts, debates, minority
+ * opinions, the consensus (if any), and recommendations for a single problem.
+ */
+export interface ReviewReport {
+    /** Stable, unique report id. */
+    id: string;
+    /** The problem the report pertains to. */
+    problemId: string;
+    /** ISO 8601 timestamp when the report was generated. */
+    generatedAt: string;
+    /** Short human-readable summary. */
+    summary: string;
+    /** All analyses included in the review. */
+    analyses: Analysis[];
+    /** All conflicts detected. */
+    conflicts: Conflict[];
+    /** All debates held. */
+    debates: Debate[];
+    /** All minority opinions recorded. */
+    minorityOpinions: MinorityOpinion[];
+    /** The consensus reached, if any. */
+    consensus: Consensus | null;
+    /** Actionable recommendations. */
+    recommendations: string[];
+}
+/** Strength of the consensus behind a synthesized decision. */
+export type ConsensusLevel = 'unanimous' | 'strong' | 'majority' | 'split' | 'none';
+/**
+ * The final, defensible decision synthesized from the consensus, analyses,
+ * conflicts, and minority opinions. Includes an explicit confidence and
+ * rationale.
+ */
+export interface Decision {
+    /** Stable, unique decision id. */
+    id: string;
+    /** The problem the decision pertains to. */
+    problemId: string;
+    /** The decision text. */
+    decision: string;
+    /** Rationale supporting the decision. */
+    rationale: string;
+    /** Confidence in the decision, in `[0, 1]`. */
+    confidence: number;
+    /** Strength of the consensus behind the decision. */
+    consensusLevel: ConsensusLevel;
+    /** Ids of the specialists who participated. */
+    participants: string[];
+    /** ISO 8601 timestamp when the decision was generated. */
+    generatedAt: string;
+}
+/**
+ * Configuration for the council and its sub-components. All fields are
+ * optional and have sensible defaults.
+ */
+export interface CouncilConfig {
+    /** Weighted support ratio required to reach consensus. Default `0.6`. */
+    consensusThreshold?: number;
+    /**
+     * Absolute deviation from the median confidence above which an analysis is
+     * considered an outlier. Default `0.25`.
+     */
+    outlierThreshold?: number;
+    /** Maximum number of rounds per debate. Default `10`. */
+    maxDebateRounds?: number;
+    /** Log level for any logger created internally. Default `'info'`. */
+    logLevel?: LogLevel;
+    /** Logger to use. Defaults to a `ConsoleLogger` at `logLevel`. */
+    logger?: Logger;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types/util.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @manya-os/council — shared text utilities.
+ *
+ * Small, dependency-free helpers used by the router, conflict, and consensus
+ * modules to tokenize and compare short pieces of natural-language text. These
+ * are intentionally simple — they are NOT an NLP pipeline. Polarity inference
+ * is a keyword-counting heuristic (with light stemming) so that conflict
+ * detection and consensus building remain deterministic, explainable, and
+ * testable.
+ *
+ * Copyright 2024 Manya Hael Foundation. All rights reserved.
+ * Licensed under the Apache License, Version 2.0.
+ */
+/** Common English stop-words. Kept short and conservative. */
+export declare const STOP_WORDS: ReadonlySet<string>;
+/** Words that bias a text's polarity positive (recommend/approve/endorse …). */
+export declare const POSITIVE_MARKERS: ReadonlySet<string>;
+/** Words that bias a text's polarity negative (reject/oppose/forbid …). */
+export declare const NEGATIVE_MARKERS: ReadonlySet<string>;
+/**
+ * Naive suffix-stripper used to normalize tokens before marker matching.
+ * Strips `'ing'`, `'ed'`, and a trailing `'s'` from tokens of length > 4 so
+ * that `'recommends'` → `'recommend'`, `'rejected'` → `'reject'`, etc. Short
+ * tokens (length ≤ 4) are returned unchanged so that `'no'`, `'go'`, `'pass'`,
+ * `'stop'` are not corrupted.
+ */
+export declare function stem(token: string): string;
+/** Splits text into lowercase alphanumeric tokens, dropping stop-words. */
+export declare function tokenize(text: string): string[];
+/** Returns the set of tokens in `text` (lowercased, stop-words removed). */
+export declare function tokenSet(text: string): Set<string>;
+/**
+ * Jaccard similarity between two token sets: `|A ∩ B| / |A ∪ B|`.
+ * Returns `0` when either set is empty.
+ */
+export declare function jaccard(a: Set<string>, b: Set<string>): number;
+/**
+ * Infers a polarity from `text` by counting positive vs negative markers
+ * (after light stemming). Returns `'positive'` when positive markers strictly
+ * outnumber negative ones, `'negative'` when negative markers strictly
+ * outnumber positive ones, and `'neutral'` when the counts are equal or no
+ * markers are present.
+ */
+export declare function polarity(text: string): 'positive' | 'negative' | 'neutral';
+//# sourceMappingURL=util.d.ts.map

package/dist/types/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,8DAA8D;AAC9D,eAAO,MAAM,UAAU,EAAE,WAAW,CAAC,MAAM,CAUzC,CAAC;AAEH,gFAAgF;AAChF,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAK/C,CAAC;AAEH,2EAA2E;AAC3E,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAK/C,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO1C;AAED,2EAA2E;AAC3E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAM/C;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAElD;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,CAQ9D;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,CAY1E"}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@manya-os/council",
+  "version": "1.0.0",
+  "description": "Multi-agent consensus engine for the MANYA Intelligence OS — specialist routing, independent analyses, weighted confidence scoring, conflict detection, structured debate, minority opinions, consensus building, review reports, and final decision synthesis.",
+  "main": "dist/cjs/index.js",
+  "types": "dist/types/index.d.ts",
+  "scripts": {
+    "build": "node ../../scripts/build-package.js council",
+    "test": "jest",
+    "clean": "rm -rf dist build node_modules",
+    "build:types": "node ../../scripts/build-types.js council",
+    "build:bundle": "node ../../scripts/build-package.js council --no-types && node ../../scripts/build-types.js council"
+  },
+  "keywords": [
+    "manya",
+    "council",
+    "multi-agent",
+    "consensus",
+    "debate",
+    "specialist",
+    "routing",
+    "conflict-detection",
+    "minority-opinion",
+    "decision-synthesis",
+    "agent-council"
+  ],
+  "author": "Uviwe Menyiwe (Azura Daemon) <foundation@manyahael.org>",
+  "license": "Apache-2.0",
+  "dependencies": {},
+  "devDependencies": {},
+  "module": "dist/esm/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.mjs",
+      "default": "./dist/cjs/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ]
+}