@its-not-rocket-science/ananke 0.1.0

package/dist/src/competence/index.js

@@ -0,0 +1,13 @@
+// src/competence/index.ts — Phase 34-40: Competence module re-exports
+export * from "./crafting.js";
+export * from "./navigation.js";
+export * from "./naturalist.js";
+export * from "./interspecies.js";
+export * from "./language.js";
+export * from "./teaching.js";
+export * from "./willpower.js";
+export * from "./engineering.js";
+export * from "./acoustic.js";
+export * from "./performance.js";
+export * from "./catalogue.js";
+export * from "./framework.js";

package/dist/src/competence/interspecies.d.ts

@@ -0,0 +1,81 @@
+import type { Q, I32 } from "../units.js";
+import type { Entity } from "../sim/entity.js";
+/**
+ * Inter-species profile tracking empathy and species-specific comprehension.
+ */
+export interface InterSpeciesProfile {
+    /** Base empathy quotient for cross-species interaction. */
+    empathy_Q: Q;
+    /** Species IDs with which the entity has deep familiarity. */
+    speciesAffinity: string[];
+    /** Map of species ID → comprehension quality for signaling. */
+    signalVocab: Map<string, Q>;
+}
+/**
+ * Signal action for cross-species communication (non-verbal).
+ */
+export interface SignalSpec {
+    /** Target species to signal. */
+    targetSpecies: string;
+    /** Intent being communicated. */
+    intent: "calm" | "submit" | "ally" | "territory";
+    /** Base fear level of the target animal/entity (0 = calm, 1 = terrified). */
+    targetFearQ: Q;
+}
+/**
+ * Outcome of a signal attempt.
+ */
+export interface SignalOutcome {
+    /** True if signal was successfully communicated and understood. */
+    success: boolean;
+    /** Quality of comprehension (0–1). */
+    comprehension_Q: Q;
+    /** True if signal aggravated the target (hostile misinterpretation). */
+    aggravated: boolean;
+}
+/**
+ * Latency penalty context for unfamiliar species combat.
+ */
+export interface UnfamiliarSpeciesContext {
+    /** The entity making decisions. */
+    entity: Entity;
+    /** Species ID of the opponent. */
+    opponentSpecies: string;
+}
+/**
+ * Compute latency penalty when facing an unfamiliar species.
+ *
+ * Formula: latencyPenalty_ms = (1.0 − interSpecies) × 0.080 (up to +80ms)
+ *
+ * @param entity - The entity experiencing unfamiliarity penalty.
+ * @param opponentSpecies - Species ID of the opponent.
+ * @returns Penalty in milliseconds (fixed-point I32), or 0 if species is familiar.
+ */
+export declare function computeUnfamiliarSpeciesLatencyPenalty(entity: Entity, opponentSpecies: string): I32;
+/**
+ * Resolve a cross-species signal attempt.
+ *
+ * Formula:
+ *   P_success = empathy_Q × signalVocab(targetSpecies) × (1 − animalFearQ × 0.60)
+ *   aggravated = (empathy_Q < AGGRAVATION_THRESHOLD) && (targetFearQ > q(0.50))
+ *
+ * @param entity - The entity sending the signal.
+ * @param spec - Signal specification.
+ * @param seed - Deterministic seed for RNG variance.
+ * @returns Signal outcome with success, comprehension quality, and aggravation flag.
+ */
+export declare function resolveSignal(entity: Entity, spec: SignalSpec, seed: number): SignalOutcome;
+/**
+ * Check if entity has affinity with a given species.
+ */
+export declare function hasSpeciesAffinity(entity: Entity, species: string): boolean;
+/**
+ * Build a default signal vocabulary for a species.
+ * Used for populating default comprehension levels.
+ */
+export declare function buildDefaultSignalVocab(speciesId: string): Map<string, Q>;
+/**
+ * Get effective inter-species empathy for an entity.
+ * Returns interSpecies cognition value, or default q(0.35) if absent.
+ */
+export declare function getEffectiveEmpathy(entity: Entity): Q;

package/dist/src/competence/interspecies.js

@@ -0,0 +1,108 @@
+// src/competence/interspecies.ts — Phase 36: Inter-Species Intelligence & Xenodiplomacy
+//
+// Inter-species intelligence models the ability to understand, read, and communicate
+// with minds operating on fundamentally different cognitive and sensory substrates.
+//
+// No kernel import — pure resolution module.
+import { SCALE, q, clampQ, qMul, mulDiv } from "../units.js";
+import { makeRng } from "../rng.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+/** Maximum latency penalty in milliseconds (80ms at interSpecies q(0.0)). */
+const MAX_LATENCY_PENALTY_MS = 80 * SCALE.s / 1000; // 80ms in Q-units
+/** Scaling factor: penalty = (1.0 − interSpecies) × MAX_LATENCY_PENALTY_MS. */
+const LATENCY_PENALTY_SCALE = MAX_LATENCY_PENALTY_MS;
+/** Base success probability for signaling without vocabulary. */
+const SIGNAL_BASE_PROBABILITY = q(0.10);
+/** Aggravation threshold: low empathy + high fear → possible hostile reaction. */
+const AGGRAVATION_THRESHOLD = q(0.30);
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Compute latency penalty when facing an unfamiliar species.
+ *
+ * Formula: latencyPenalty_ms = (1.0 − interSpecies) × 0.080 (up to +80ms)
+ *
+ * @param entity - The entity experiencing unfamiliarity penalty.
+ * @param opponentSpecies - Species ID of the opponent.
+ * @returns Penalty in milliseconds (fixed-point I32), or 0 if species is familiar.
+ */
+export function computeUnfamiliarSpeciesLatencyPenalty(entity, opponentSpecies) {
+    // Check if entity has affinity with opponent species
+    const affinity = entity.attributes.cognition?.speciesAffinity ?? [];
+    if (affinity.includes(opponentSpecies)) {
+        return 0; // No penalty for familiar species
+    }
+    const interSpecies = (entity.attributes.cognition?.interSpecies ?? q(0.35));
+    // penalty_ms = (SCALE.Q - interSpecies) / SCALE.Q × 80ms
+    const penaltyScale = clampQ((SCALE.Q - interSpecies), 0, SCALE.Q);
+    const penaltyMs = mulDiv(penaltyScale, LATENCY_PENALTY_SCALE, SCALE.Q);
+    return penaltyMs;
+}
+/**
+ * Resolve a cross-species signal attempt.
+ *
+ * Formula:
+ *   P_success = empathy_Q × signalVocab(targetSpecies) × (1 − animalFearQ × 0.60)
+ *   aggravated = (empathy_Q < AGGRAVATION_THRESHOLD) && (targetFearQ > q(0.50))
+ *
+ * @param entity - The entity sending the signal.
+ * @param spec - Signal specification.
+ * @param seed - Deterministic seed for RNG variance.
+ * @returns Signal outcome with success, comprehension quality, and aggravation flag.
+ */
+export function resolveSignal(entity, spec, seed) {
+    const interSpecies = (entity.attributes.cognition?.interSpecies ?? q(0.35));
+    const empathy_Q = interSpecies; // Use interSpecies as empathy base
+    // Get vocabulary comprehension for target species
+    const vocab = entity.attributes.cognition?.signalVocab ?? new Map();
+    const vocabComp = vocab.get(spec.targetSpecies) ?? q(0.20);
+    // Base success probability
+    const baseProb = clampQ(qMul(empathy_Q, vocabComp), q(0), SCALE.Q);
+    // Fear penalty: fearful targets are harder to communicate with
+    // P_success *= (1 − fear × 0.60)
+    const fearPenalty = mulDiv(spec.targetFearQ, q(0.60), SCALE.Q);
+    const fearMul = clampQ((SCALE.Q - fearPenalty), q(0.20), SCALE.Q);
+    const finalProb = clampQ(qMul(baseProb, fearMul), q(0), SCALE.Q);
+    // RNG check
+    const rng = makeRng(seed, SCALE.Q);
+    const roll = rng.q01();
+    const success = roll < finalProb;
+    // Comprehension quality: empathy × vocab × (0.7–1.1 RNG variance)
+    const varianceRoll = rng.q01();
+    const variance = clampQ((q(0.70) + mulDiv(varianceRoll, q(0.40), SCALE.Q)), q(0.70), q(1.10));
+    const comprehension_Q = clampQ(qMul(qMul(empathy_Q, vocabComp), variance), q(0), SCALE.Q);
+    // Aggravation check: low empathy + fearful target can trigger hostile reaction
+    const aggravated = empathy_Q < AGGRAVATION_THRESHOLD && spec.targetFearQ > q(0.50);
+    return { success, comprehension_Q, aggravated };
+}
+/**
+ * Check if entity has affinity with a given species.
+ */
+export function hasSpeciesAffinity(entity, species) {
+    const affinity = entity.attributes.cognition?.speciesAffinity ?? [];
+    return affinity.includes(species);
+}
+/**
+ * Build a default signal vocabulary for a species.
+ * Used for populating default comprehension levels.
+ */
+export function buildDefaultSignalVocab(speciesId) {
+    const vocab = new Map();
+    // Default low comprehension with most species
+    const commonSpecies = ["human", "elf", "dwarf", "orc", "goblin", "troll", "wolf", "bear"];
+    for (const s of commonSpecies) {
+        if (s !== speciesId) {
+            vocab.set(s, q(0.15));
+        }
+    }
+    // Higher comprehension with own species
+    vocab.set(speciesId, q(0.80));
+    return vocab;
+}
+// ── Backward compatibility helpers ────────────────────────────────────────────
+/**
+ * Get effective inter-species empathy for an entity.
+ * Returns interSpecies cognition value, or default q(0.35) if absent.
+ */
+export function getEffectiveEmpathy(entity) {
+    return (entity.attributes.cognition?.interSpecies ?? q(0.35));
+}

package/dist/src/competence/language.d.ts

@@ -0,0 +1,79 @@
+import type { Q } from "../units.js";
+import type { Entity } from "../sim/entity.js";
+/**
+ * Language capacity with fluency level.
+ */
+export interface LanguageCapacity {
+    /** Language identifier (e.g., "common", "elvish", "klingonese"). */
+    languageId: string;
+    /** Fluency level: q(1.0) = native, q(0.50) = conversational, q(0.20) = survival. */
+    fluency_Q: Q;
+}
+/**
+ * Outcome of a command transmission to a formation.
+ */
+export interface CommandTransmission {
+    /** Fraction of formation receiving correctly (0–1). */
+    receptionRate_Q: Q;
+    /** Delay in ticks before command is fully transmitted. */
+    transmissionDelay_ticks: number;
+}
+/**
+ * Specification for language-based communication check.
+ */
+export interface LanguageCheckSpec {
+    /** Target language being used. */
+    targetLanguage: string;
+    /** Minimum fluency required for the communication. */
+    minFluency_Q?: Q;
+}
+/**
+ * Outcome of a language check.
+ */
+export interface LanguageCheckOutcome {
+    /** True if entity has sufficient fluency. */
+    canCommunicate: boolean;
+    /** Entity's fluency in the target language. */
+    fluency_Q: Q;
+    /** Communication quality multiplier (0–1). */
+    qualityMul_Q: Q;
+}
+/**
+ * Get entity's fluency in a specific language.
+ * Returns default q(0.50) if no languages defined or language not found.
+ */
+export declare function getLanguageFluency(entity: Entity, languageId: string): Q;
+/**
+ * Check if entity can communicate in a language and at what quality.
+ */
+export declare function checkLanguage(entity: Entity, spec: LanguageCheckSpec): LanguageCheckOutcome;
+/**
+ * Compute communication penalty between two entities speaking different languages.
+ * Returns the minimum fluency between initiator's target language and target's response language.
+ */
+export declare function computeLanguageBarrier(initiator: Entity, target: Entity, initiatorLanguage: string, targetLanguage: string): Q;
+/**
+ * Resolve command transmission to a formation.
+ *
+ * Formula:
+ *   receptionRate_Q = linguistic × formationBonus(formationSize)
+ *   transmissionDelay_ticks = ceil(formationSize / (linguistic × 20))
+ *
+ * @param commander - The entity issuing commands.
+ * @param formationSize - Number of units in the formation.
+ * @returns Command transmission outcome.
+ */
+export declare function resolveCommandTransmission(commander: Entity, formationSize: number): CommandTransmission;
+/**
+ * Compute effective command range based on linguistic skill.
+ * Higher linguistic = commands carry farther.
+ */
+export declare function computeCommandRange_m(commander: Entity): number;
+/**
+ * Check if entity has any language capacity defined.
+ */
+export declare function hasLanguageCapacity(entity: Entity): boolean;
+/**
+ * Get native language (fluency >= 0.80) or highest fluency language.
+ */
+export declare function getPrimaryLanguage(entity: Entity): string | undefined;

package/dist/src/competence/language.js

@@ -0,0 +1,115 @@
+// src/competence/language.ts — Phase 37: Linguistic Intelligence
+//
+// Linguistic intelligence governs command clarity, multilingual competence,
+// persuasive argument structure, and written record quality.
+//
+// No kernel import — pure resolution module.
+import { SCALE, q, clampQ, qMul, mulDiv } from "../units.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+/** Base reception rate at linguistic q(0.50) for formation size 1. */
+const BASE_RECEPTION_RATE = q(0.70);
+/** Maximum formation size before reception penalties apply. */
+const OPTIMAL_FORMATION_SIZE = 10;
+/** Base delay divisor: linguistic × BASE_DELAY_DIVISOR. */
+const BASE_DELAY_DIVISOR = 20;
+/** Minimum fluency for basic communication. */
+const MIN_FLUENCY_THRESHOLD = q(0.10);
+/** Default fluency when entity has no languages defined. */
+const DEFAULT_FLUENCY = q(0.50);
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Get entity's fluency in a specific language.
+ * Returns default q(0.50) if no languages defined or language not found.
+ */
+export function getLanguageFluency(entity, languageId) {
+    const languages = entity.attributes.languages;
+    if (!languages || languages.length === 0) {
+        return DEFAULT_FLUENCY;
+    }
+    const lang = languages.find((l) => l.languageId === languageId);
+    return lang?.fluency_Q ?? MIN_FLUENCY_THRESHOLD;
+}
+/**
+ * Check if entity can communicate in a language and at what quality.
+ */
+export function checkLanguage(entity, spec) {
+    const fluency_Q = getLanguageFluency(entity, spec.targetLanguage);
+    const minFluency = spec.minFluency_Q ?? MIN_FLUENCY_THRESHOLD;
+    const canCommunicate = fluency_Q >= minFluency;
+    // Quality multiplier scales with fluency above minimum
+    const qualityMul_Q = canCommunicate
+        ? clampQ(mulDiv(fluency_Q, SCALE.Q, q(1.0)), q(0.20), SCALE.Q)
+        : q(0);
+    return { canCommunicate, fluency_Q, qualityMul_Q };
+}
+/**
+ * Compute communication penalty between two entities speaking different languages.
+ * Returns the minimum fluency between initiator's target language and target's response language.
+ */
+export function computeLanguageBarrier(initiator, target, initiatorLanguage, targetLanguage) {
+    const initiatorFluency = getLanguageFluency(initiator, initiatorLanguage);
+    const targetFluency = getLanguageFluency(target, targetLanguage);
+    // Communication limited by the least fluent participant
+    return Math.min(initiatorFluency, targetFluency);
+}
+/**
+ * Resolve command transmission to a formation.
+ *
+ * Formula:
+ *   receptionRate_Q = linguistic × formationBonus(formationSize)
+ *   transmissionDelay_ticks = ceil(formationSize / (linguistic × 20))
+ *
+ * @param commander - The entity issuing commands.
+ * @param formationSize - Number of units in the formation.
+ * @returns Command transmission outcome.
+ */
+export function resolveCommandTransmission(commander, formationSize) {
+    const linguistic = (commander.attributes.cognition?.linguistic ?? q(0.50));
+    // Formation size penalty: larger formations are harder to coordinate
+    // Bonus = 1.0 for size <= 10, then degrades linearly
+    const sizePenalty = Math.max(0, formationSize - OPTIMAL_FORMATION_SIZE);
+    const formationBonus = clampQ((SCALE.Q - mulDiv(sizePenalty, q(0.02), SCALE.Q)), q(0.30), SCALE.Q);
+    // Reception rate: linguistic skill × formation size bonus
+    const receptionRate_Q = clampQ(qMul(linguistic, formationBonus), q(0.10), SCALE.Q);
+    // Delay: larger formations + lower linguistic = more delay
+    // delay = ceil(formationSize / (linguistic × 20))
+    const linguisticFactor = Math.max(1, mulDiv(linguistic, BASE_DELAY_DIVISOR, SCALE.Q));
+    const transmissionDelay_ticks = Math.ceil(formationSize / linguisticFactor);
+    return { receptionRate_Q, transmissionDelay_ticks };
+}
+/**
+ * Compute effective command range based on linguistic skill.
+ * Higher linguistic = commands carry farther.
+ */
+export function computeCommandRange_m(commander) {
+    const linguistic = (commander.attributes.cognition?.linguistic ?? q(0.50));
+    const baseRange = 50; // 50 meters base
+    const maxRange = 500; // 500 meters max
+    // Range scales from base to max based on linguistic
+    const range = baseRange + mulDiv(linguistic, (maxRange - baseRange), SCALE.Q);
+    return Math.round(range);
+}
+// ── Backward compatibility ────────────────────────────────────────────────────
+/**
+ * Check if entity has any language capacity defined.
+ */
+export function hasLanguageCapacity(entity) {
+    const languages = entity.attributes.languages;
+    return languages !== undefined && languages.length > 0;
+}
+/**
+ * Get native language (fluency >= 0.80) or highest fluency language.
+ */
+export function getPrimaryLanguage(entity) {
+    const languages = entity.attributes.languages;
+    if (!languages || languages.length === 0) {
+        return undefined;
+    }
+    // Find native-level language first
+    const native = languages.find((l) => l.fluency_Q >= q(0.80));
+    if (native)
+        return native.languageId;
+    // Otherwise return highest fluency
+    const highest = languages.reduce((best, current) => current.fluency_Q > best.fluency_Q ? current : best);
+    return highest.languageId;
+}

package/dist/src/competence/naturalist.d.ts

@@ -0,0 +1,97 @@
+import type { Q } from "../units.js";
+import type { Entity } from "../sim/entity.js";
+export interface TrackingSpec {
+    /** Seconds since quarry passed. */
+    trackAge_s: number;
+    /** Terrain type affecting track preservation. */
+    terrain: "ideal" | "rain" | "urban" | "deep_water" | "forest";
+    /** Species identifier of the quarry. */
+    quarrySpecies: string;
+}
+export interface TrackingOutcome {
+    /** Confidence in track reading; above q(0.60) = reliable direction. */
+    confidence_Q: Q;
+    /** Maximum range at which entity can follow this track (metres). */
+    trackRange_m: number;
+}
+export interface ForagingSpec {
+    /** Hours spent searching. */
+    searchHours: number;
+    /** Biome type affecting yield. */
+    biome: "forest" | "plains" | "desert" | "swamp" | "mountain";
+    /** Season affecting plant availability. */
+    season: "spring" | "summer" | "autumn" | "winter";
+}
+export interface ForagingOutcome {
+    /** Items found per hour of searching. */
+    itemsFound: number;
+    /** Quality of medicinal plants found (0–1). */
+    herbQuality_Q: Q;
+    /** True if a poisonous plant was mistaken for edible. */
+    misidentified: boolean;
+}
+export interface TamingSpec {
+    /** Species identifier of the animal. */
+    animalSpecies: string;
+    /** Base fear level of the animal (0 = calm, 1 = terrified). */
+    animalFearQ: Q;
+    /** Effort factor: hours spent this session (normalized: 1.0 = standard 4-hour session). */
+    effortFactor: Q;
+    /** Number of prior successful interactions with this species. */
+    priorSuccesses: number;
+}
+export interface TamingOutcome {
+    /** Trust level: 0 = hostile → 1 = fully tamed. */
+    trust_Q: Q;
+    /** True if animal attacked handler this session. */
+    attacked: boolean;
+}
+/**
+ * Resolve a tracking attempt.
+ *
+ * Formula:
+ *   confidence_Q = naturalist × ageMul × terrainMul × speciesMul
+ *   If quarrySpecies in entity's speciesAffinity: +q(0.15)
+ *   trackRange_m = baseRange × confidence_Q (with floor at naturalist × 10m)
+ *
+ * @param entity - The tracker; uses `cognition.naturalist`.
+ * @param spec   - Tracking specification.
+ * @param _seed  - Reserved for future variance; currently unused.
+ */
+export declare function resolveTracking(entity: Entity, spec: TrackingSpec, _seed: number): TrackingOutcome;
+/**
+ * Resolve a foraging/herbalism attempt.
+ *
+ * Formula:
+ *   yield = baseYield × naturalist × seasonMul × searchHours
+ *   herbQuality_Q = clamp(naturalist × randomFactor, 0, 1)
+ *   P_misidentified = max(0, 0.30 − naturalist × 0.40)
+ *     (troll naturalist 0.50 → ~10%; elf naturalist 0.78 → ~0%)
+ *
+ * @param entity - The forager; uses `cognition.naturalist`.
+ * @param spec   - Foraging specification.
+ * @param seed   - Deterministic seed for quality variance.
+ */
+export declare function resolveForaging(entity: Entity, spec: ForagingSpec, seed: number): ForagingOutcome;
+/**
+ * Resolve an animal taming attempt.
+ *
+ * Formula:
+ *   trust_Q = clamp(naturalist × interSpecies × effortFactor − animalFearQ × 0.50, 0, 1)
+ *   attacked = RNG < (animalFearQ − trust_Q) × 0.30  (high fear + low trust = danger)
+ *
+ * Full taming (trust_Q ≥ q(0.90)) makes the animal available as an ally.
+ *
+ * @param entity - The handler; uses `cognition.naturalist` and `cognition.interSpecies`.
+ * @param spec   - Taming specification.
+ * @param seed   - Deterministic seed for attack check.
+ */
+export declare function resolveTaming(entity: Entity, spec: TamingSpec, seed: number): TamingOutcome;
+/**
+ * Check if an animal is fully tamed (available as ally).
+ */
+export declare function isFullyTamed(trust_Q: Q): boolean;
+/**
+ * Check if tracking confidence is reliable.
+ */
+export declare function isTrackingReliable(confidence_Q: Q): boolean;