@its-not-rocket-science/ananke 0.1.0

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

@@ -0,0 +1,101 @@
+import type { Q } from "../units.js";
+import type { Entity } from "../sim/entity.js";
+/** Acoustic signature of an entity — how much noise it produces. */
+export interface AcousticSignature {
+    /** Base noise level in arbitrary units (0 = silent, 100 = very loud). */
+    baseNoise: number;
+    /** Noise from movement (scales with velocity). */
+    movementNoise: number;
+    /** Noise from equipment (armour clanking, weapon swinging). */
+    equipmentNoise: number;
+    /** Total noise level (computed). */
+    totalNoise: number;
+}
+/** Formation signal types for military/organized coordination. */
+export type FormationSignal = "advance" | "retreat" | "hold" | "flank_left" | "flank_right" | "rally";
+/** Outcome of a formation signal transmission attempt. */
+export interface FormationSignalOutcome {
+    /** Clarity of the signal (0–1). */
+    clarity_Q: Q;
+    /** Whether the signal was successfully received. */
+    received: boolean;
+    /** Latency in milliseconds before signal is understood. */
+    latency_ms: number;
+}
+/** Detection outcome for acoustic sensing. */
+export interface AcousticDetectionOutcome {
+    /** Detection confidence (0–1). */
+    confidence_Q: Q;
+    /** Estimated direction in degrees (0–360, -1 if unknown). */
+    estimatedDirection_deg: number;
+    /** Estimated distance in metres (-1 if unknown). */
+    estimatedDistance_m: number;
+    /** Whether detection is certain enough to act on. */
+    detected: boolean;
+}
+/**
+ * Derive the acoustic signature of an entity.
+ *
+ * Formula:
+ *   baseNoise = 50 (normal human movement)
+ *   stealth reduces baseNoise: base × (1 − stealth × 0.60)
+ *   movementNoise = velocity_mps × 10
+ *   equipmentNoise = based on armour material and weapon mass
+ *
+ * @param entity - The entity to analyze.
+ * @returns Acoustic signature with all noise components.
+ */
+export declare function deriveAcousticSignature(entity: Entity): AcousticSignature;
+/**
+ * Detect an acoustic signature.
+ *
+ * Formula:
+ *   detection_Q = clamp(sourceNoise / dist_m × listener.musical × SCALE_ACOUSTIC, 0, 1)
+ *
+ * Higher sourceNoise = easier to detect.
+ * Higher listener musical intelligence = better detection.
+ * Distance degrades detection linearly.
+ *
+ * @param listener - The entity attempting to detect.
+ * @param source - The entity producing sound.
+ * @param dist_m - Distance between entities in metres.
+ * @returns Detection confidence and metadata.
+ */
+export declare function detectAcousticSignature(listener: Entity, source: Entity, dist_m: number): AcousticDetectionOutcome;
+/**
+ * Resolve a formation signal transmission.
+ *
+ * Used for military coordination: drums, horns, whistles, shouted commands.
+ *
+ * Formula:
+ *   clarity_Q = musical(signaller) × musical(listener) × rangeFactor(dist_m)
+ *   received = clarity_Q >= SIGNAL_RECEPTION_THRESHOLD
+ *   latency_ms = BASE_LATENCY_MS × (1 − avgMusical × 0.50)
+ *
+ * Satyr signaller (0.95) → Elf listeners (0.85) → near-perfect reception at long range.
+ * Troll → Troll → commands degrade rapidly beyond a few metres.
+ *
+ * @param signaller - The entity sending the signal.
+ * @param signal - The formation signal type.
+ * @param listener - The entity receiving the signal.
+ * @param dist_m - Distance between entities in metres.
+ * @returns Signal outcome with clarity and reception status.
+ */
+export declare function resolveFormationSignal(signaller: Entity, signal: FormationSignal, listener: Entity, dist_m: number): FormationSignalOutcome;
+/**
+ * Check if an entity can effectively use formation signals.
+ * Requires minimum musical intelligence to produce clear signals.
+ *
+ * @param entity - The potential signaller.
+ * @param minMusical - Minimum musical intelligence required (default q(0.40)).
+ * @returns True if entity can serve as a signaller.
+ */
+export declare function canUseFormationSignals(entity: Entity, minMusical?: Q): boolean;
+/**
+ * Calculate maximum effective signal range for a signaller.
+ *
+ * @param signaller - The entity sending signals.
+ * @param minClarity - Minimum clarity required for reception (default q(0.40)).
+ * @returns Maximum range in metres.
+ */
+export declare function calculateSignalRange(signaller: Entity, minClarity?: Q): number;

package/dist/src/competence/acoustic.js

@@ -0,0 +1,242 @@
+// src/competence/acoustic.ts — Phase 39: Musical Intelligence & Acoustic Systems
+//
+// Musical intelligence governs cognition in the time-acoustic domain:
+//   - Recognition of rhythmic patterns and sound cues
+//   - Formation signal interpretation (drums, horns)
+//   - Acoustic detection and stealth counter-detection
+//
+// No kernel import — pure resolution module.
+import { SCALE, q, clampQ, mulDiv } from "../units.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+/** Scale factor for acoustic detection formula. */
+const SCALE_ACOUSTIC = 100; // multiplier to get useful detection ranges
+/** Base detection range in metres at average musical intelligence. */
+const BASE_DETECTION_RANGE_m = 50;
+/** Maximum effective detection range. */
+const MAX_DETECTION_RANGE_m = 500;
+/** Range factor: clarity degrades with distance. */
+const RANGE_DEGRADATION_PER_METER = 0.002; // 0.2% per metre
+/** Threshold for successful signal reception. */
+const SIGNAL_RECEPTION_THRESHOLD = q(0.40);
+/** Base latency for signal interpretation in milliseconds. */
+const BASE_SIGNAL_LATENCY_MS = 200;
+/** Latency reduction from high musical intelligence. */
+const MUSICAL_LATENCY_REDUCTION_FACTOR = 0.5; // up to 50% faster
+// Noise level constants
+const NOISE_SILENT = 0;
+const NOISE_VERY_QUIET = 10;
+const NOISE_QUIET = 25;
+const NOISE_NORMAL = 50;
+const NOISE_LOUD = 75;
+const NOISE_VERY_LOUD = 100;
+// ── Helpers ───────────────────────────────────────────────────────────────────
+/**
+ * Get stealth skill value from entity (0 if not present).
+ * Higher stealth = lower noise.
+ */
+function getStealthValue(entity) {
+    // Check for stealth in skills map
+    const stealthSkill = entity.skills?.get("stealth");
+    if (stealthSkill !== undefined) {
+        // Convert SkillLevel to Q (SkillLevel is already a Q-encoded value)
+        return stealthSkill;
+    }
+    // Default: average stealth
+    return q(0.50);
+}
+/**
+ * Calculate equipment noise based on armour type.
+ */
+function calculateEquipmentNoise(entity) {
+    let noise = NOISE_NORMAL; // base walking noise
+    // Process all items in loadout
+    for (const item of entity.loadout.items) {
+        // Armour adds noise based on material
+        if (item.kind === "armour") {
+            const armour = item;
+            if (armour.material === "metal") {
+                noise += 15; // clanking
+            }
+            else if (armour.material === "leather") {
+                noise += 5; // creaking
+            }
+            // fabric/cloth is silent
+        }
+        // Weapons add noise when moved
+        if (item.kind === "weapon") {
+            const weapon = item;
+            if (weapon.mass_kg > 2000) { // heavy weapons
+                noise += 10;
+            }
+            else if (weapon.mass_kg > 1000) {
+                noise += 5;
+            }
+        }
+    }
+    return Math.min(NOISE_VERY_LOUD, noise);
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Derive the acoustic signature of an entity.
+ *
+ * Formula:
+ *   baseNoise = 50 (normal human movement)
+ *   stealth reduces baseNoise: base × (1 − stealth × 0.60)
+ *   movementNoise = velocity_mps × 10
+ *   equipmentNoise = based on armour material and weapon mass
+ *
+ * @param entity - The entity to analyze.
+ * @returns Acoustic signature with all noise components.
+ */
+export function deriveAcousticSignature(entity) {
+    // Base noise level
+    let baseNoise = NOISE_NORMAL;
+    // Stealth reduces base noise
+    const stealth = getStealthValue(entity);
+    const stealthReduction = mulDiv(stealth, q(0.60), SCALE.Q) / SCALE.Q;
+    baseNoise = Math.round(baseNoise * (1 - stealthReduction));
+    // Movement noise from velocity
+    const velocity = Math.sqrt(entity.velocity_mps.x ** 2 +
+        entity.velocity_mps.y ** 2 +
+        entity.velocity_mps.z ** 2) / SCALE.mps; // convert to m/s
+    const movementNoise = Math.round(velocity * 10);
+    // Equipment noise
+    const equipmentNoise = calculateEquipmentNoise(entity);
+    // Total noise
+    const totalNoise = Math.min(NOISE_VERY_LOUD, baseNoise + movementNoise + equipmentNoise);
+    return {
+        baseNoise,
+        movementNoise,
+        equipmentNoise,
+        totalNoise,
+    };
+}
+/**
+ * Detect an acoustic signature.
+ *
+ * Formula:
+ *   detection_Q = clamp(sourceNoise / dist_m × listener.musical × SCALE_ACOUSTIC, 0, 1)
+ *
+ * Higher sourceNoise = easier to detect.
+ * Higher listener musical intelligence = better detection.
+ * Distance degrades detection linearly.
+ *
+ * @param listener - The entity attempting to detect.
+ * @param source - The entity producing sound.
+ * @param dist_m - Distance between entities in metres.
+ * @returns Detection confidence and metadata.
+ */
+export function detectAcousticSignature(listener, source, dist_m) {
+    const musical = (listener.attributes.cognition?.musical ?? q(0.50));
+    // Get source noise
+    const signature = deriveAcousticSignature(source);
+    const sourceNoise = signature.totalNoise;
+    // Distance factor: detection degrades with distance
+    const distanceFactor = Math.max(0, 1 - dist_m * RANGE_DEGRADATION_PER_METER);
+    // Detection formula
+    const musicalNorm = musical / SCALE.Q; // 0-1
+    const rawDetection = (sourceNoise / 100) * distanceFactor * musicalNorm * SCALE_ACOUSTIC;
+    // Clamp to valid Q range
+    const confidence_Q = clampQ(Math.round(rawDetection * SCALE.Q), q(0), SCALE.Q);
+    // Detection threshold
+    const detected = confidence_Q >= q(0.30);
+    // Estimate direction (simplified: assume we can determine direction if confidence is high)
+    let estimatedDirection_deg = -1;
+    let estimatedDistance_m = -1;
+    if (confidence_Q >= q(0.50)) {
+        // Can estimate distance with moderate accuracy
+        estimatedDistance_m = Math.round(dist_m * (0.8 + Math.random() * 0.4));
+    }
+    if (confidence_Q >= q(0.70)) {
+        // Can determine direction (in a real implementation, would compute from positions)
+        estimatedDirection_deg = Math.floor(Math.random() * 360);
+    }
+    return {
+        confidence_Q,
+        estimatedDirection_deg,
+        estimatedDistance_m,
+        detected,
+    };
+}
+/**
+ * Resolve a formation signal transmission.
+ *
+ * Used for military coordination: drums, horns, whistles, shouted commands.
+ *
+ * Formula:
+ *   clarity_Q = musical(signaller) × musical(listener) × rangeFactor(dist_m)
+ *   received = clarity_Q >= SIGNAL_RECEPTION_THRESHOLD
+ *   latency_ms = BASE_LATENCY_MS × (1 − avgMusical × 0.50)
+ *
+ * Satyr signaller (0.95) → Elf listeners (0.85) → near-perfect reception at long range.
+ * Troll → Troll → commands degrade rapidly beyond a few metres.
+ *
+ * @param signaller - The entity sending the signal.
+ * @param signal - The formation signal type.
+ * @param listener - The entity receiving the signal.
+ * @param dist_m - Distance between entities in metres.
+ * @returns Signal outcome with clarity and reception status.
+ */
+export function resolveFormationSignal(signaller, signal, listener, dist_m) {
+    const signallerMusical = (signaller.attributes.cognition?.musical ?? q(0.50));
+    const listenerMusical = (listener.attributes.cognition?.musical ?? q(0.50));
+    // Range factor degrades with distance
+    const rangeFactor = Math.max(0, 1 - dist_m * RANGE_DEGRADATION_PER_METER * 0.5); // slower degradation for intentional signals
+    // Musical product (both need musical intelligence for clear transmission)
+    const signallerNorm = signallerMusical / SCALE.Q;
+    const listenerNorm = listenerMusical / SCALE.Q;
+    const musicalProduct = signallerNorm * listenerNorm;
+    // Clarity calculation
+    const rawClarity = musicalProduct * rangeFactor * SCALE_ACOUSTIC / 100;
+    const clarity_Q = clampQ(Math.round(rawClarity * SCALE.Q), q(0), SCALE.Q);
+    // Reception check
+    const received = clarity_Q >= SIGNAL_RECEPTION_THRESHOLD;
+    // Latency: better musical intelligence = faster interpretation
+    const avgMusical = (signallerNorm + listenerNorm) / 2;
+    const latencyReduction = avgMusical * MUSICAL_LATENCY_REDUCTION_FACTOR;
+    const latency_ms = Math.round(BASE_SIGNAL_LATENCY_MS * (1 - latencyReduction));
+    return {
+        clarity_Q,
+        received,
+        latency_ms,
+    };
+}
+/**
+ * Check if an entity can effectively use formation signals.
+ * Requires minimum musical intelligence to produce clear signals.
+ *
+ * @param entity - The potential signaller.
+ * @param minMusical - Minimum musical intelligence required (default q(0.40)).
+ * @returns True if entity can serve as a signaller.
+ */
+export function canUseFormationSignals(entity, minMusical = q(0.40)) {
+    const musical = (entity.attributes.cognition?.musical ?? q(0.50));
+    return musical >= minMusical;
+}
+/**
+ * Calculate maximum effective signal range for a signaller.
+ *
+ * @param signaller - The entity sending signals.
+ * @param minClarity - Minimum clarity required for reception (default q(0.40)).
+ * @returns Maximum range in metres.
+ */
+export function calculateSignalRange(signaller, minClarity = q(0.40)) {
+    const signallerMusical = (signaller.attributes.cognition?.musical ?? q(0.50));
+    const musicalNorm = signallerMusical / SCALE.Q;
+    // clarity = musicalProduct * rangeFactor * SCALE_ACOUSTIC / SCALE.Q
+    // At distance 0, rangeFactor = 1, so maxClarity = musicalProduct * SCALE_ACOUSTIC / SCALE.Q
+    // Assuming average listener (musical = 0.50)
+    const listenerNorm = 0.50;
+    const musicalProduct = musicalNorm * listenerNorm;
+    // Max possible clarity at point-blank
+    const maxClarity = musicalProduct * SCALE_ACOUSTIC; // This gives 0-100 range
+    const minClarityNorm = minClarity / SCALE.Q; // Convert Q to 0-1
+    if (maxClarity < minClarityNorm * 100) {
+        return 0; // Cannot reach minimum clarity even at point-blank
+    }
+    // minClarityNorm = musicalProduct * (1 - dist * degradation * 0.5) * SCALE_ACOUSTIC / SCALE.Q
+    // Solve for dist where clarity = minClarity
+    const requiredRatio = (minClarityNorm * 100) / (musicalProduct * SCALE_ACOUSTIC);
+    const maxDist = (1 - requiredRatio) / (RANGE_DEGRADATION_PER_METER * 0.5);
+    return Math.min(MAX_DETECTION_RANGE_m, Math.round(maxDist));
+}

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

@@ -0,0 +1,30 @@
+import type { Q } from "../units.js";
+/** Domain of competence — maps to cognitive intelligence types. */
+export type CompetenceDomain = "linguistic" | "logicalMathematical" | "spatial" | "bodilyKinesthetic" | "musical" | "interpersonal" | "intrapersonal" | "naturalist" | "interSpecies";
+/** A single competence task definition. */
+export interface CompetenceTask {
+    /** Unique task identifier. */
+    taskId: string;
+    /** Primary competence domain. */
+    domain: CompetenceDomain;
+    /** Secondary domain (optional, for compound tasks). */
+    secondaryDomain?: CompetenceDomain;
+    /** Difficulty rating (0–1). */
+    difficulty_Q: Q;
+    /** Base time required in seconds. */
+    timeBase_s: number;
+    /** Required tool/equipment (optional). */
+    requiredTool?: string;
+    /** Human-readable description. */
+    description: string;
+}
+/** Read-only catalogue of all competence tasks. */
+export declare const COMPETENCE_CATALOGUE: readonly CompetenceTask[];
+/** Lookup map for taskId → task. */
+export declare const COMPETENCE_TASK_BY_ID: ReadonlyMap<string, CompetenceTask>;
+/** Get a task by ID. Returns undefined if not found. */
+export declare function getTaskById(taskId: string): CompetenceTask | undefined;
+/** Check if a task exists in the catalogue. */
+export declare function hasTask(taskId: string): boolean;
+/** Get all tasks for a specific domain. */
+export declare function getTasksByDomain(domain: CompetenceDomain): CompetenceTask[];

package/dist/src/competence/catalogue.js

@@ -0,0 +1,241 @@
+// src/competence/catalogue.ts — Phase 40: Competence Catalogue
+//
+// Predefined competence tasks with difficulty, time requirements, and domain.
+// Parallel to weapons and food catalogues.
+import { q } from "../units.js";
+// ── Catalogue Entries ─────────────────────────────────────────────────────────
+const entries = [
+    // ── Bodily-Kinesthetic (crafting, physical skill) ────────────────────────────
+    {
+        taskId: "craft_sword_basic",
+        domain: "bodilyKinesthetic",
+        difficulty_Q: q(0.40),
+        timeBase_s: 14400, // 4 hours
+        requiredTool: "forge",
+        description: "Forge a basic serviceable sword",
+    },
+    {
+        taskId: "craft_sword_master",
+        domain: "bodilyKinesthetic",
+        difficulty_Q: q(0.85),
+        timeBase_s: 28800, // 8 hours
+        requiredTool: "forge",
+        description: "Forge a masterwork sword",
+    },
+    {
+        taskId: "treat_wound_field",
+        domain: "bodilyKinesthetic",
+        difficulty_Q: q(0.50),
+        timeBase_s: 300, // 5 minutes
+        requiredTool: "medical_kit",
+        description: "Field treatment of bleeding wound",
+    },
+    {
+        taskId: "perform_surgery",
+        domain: "bodilyKinesthetic",
+        difficulty_Q: q(0.75),
+        timeBase_s: 3600, // 1 hour
+        requiredTool: "surgical_kit",
+        description: "Surgical repair of internal injuries",
+    },
+    // ── Spatial (navigation, wayfinding) ────────────────────────────────────────
+    {
+        taskId: "navigate_wilderness",
+        domain: "spatial",
+        difficulty_Q: q(0.50),
+        timeBase_s: 3600, // per hour of travel
+        description: "Navigate through untracked wilderness",
+    },
+    {
+        taskId: "navigate_urban",
+        domain: "spatial",
+        difficulty_Q: q(0.30),
+        timeBase_s: 600, // 10 minutes
+        description: "Find route through complex urban environment",
+    },
+    {
+        taskId: "read_map",
+        domain: "spatial",
+        difficulty_Q: q(0.25),
+        timeBase_s: 60, // 1 minute
+        requiredTool: "map",
+        description: "Interpret map and locate position",
+    },
+    // ── Naturalist (tracking, foraging, animal handling) ─────────────────────────
+    {
+        taskId: "track_quarry_fresh",
+        domain: "naturalist",
+        difficulty_Q: q(0.30),
+        timeBase_s: 1800, // 30 minutes
+        description: "Track quarry with fresh trail (< 1 hour)",
+    },
+    {
+        taskId: "track_quarry_aged",
+        domain: "naturalist",
+        difficulty_Q: q(0.60),
+        timeBase_s: 3600, // 1 hour
+        description: "Track quarry with aged trail (> 1 day)",
+    },
+    {
+        taskId: "forage_herbs",
+        domain: "naturalist",
+        difficulty_Q: q(0.35),
+        timeBase_s: 3600, // 1 hour
+        description: "Search for medicinal herbs",
+    },
+    {
+        taskId: "identify_herb",
+        domain: "naturalist",
+        difficulty_Q: q(0.25),
+        timeBase_s: 60, // 1 minute
+        description: "Identify unknown plant and properties",
+    },
+    {
+        taskId: "tame_horse",
+        domain: "naturalist",
+        secondaryDomain: "interSpecies",
+        difficulty_Q: q(0.40),
+        timeBase_s: 7200, // 2 hours per session
+        description: "Build trust with untrained horse",
+    },
+    // ── Inter-Species (communication across species boundaries) ───────────────────
+    {
+        taskId: "signal_alien_species",
+        domain: "interSpecies",
+        difficulty_Q: q(0.60),
+        timeBase_s: 300, // 5 minutes
+        description: "Attempt first-contact communication with unknown species",
+    },
+    {
+        taskId: "calm_agitated_beast",
+        domain: "interSpecies",
+        difficulty_Q: q(0.55),
+        timeBase_s: 600, // 10 minutes
+        description: "Calm frightened or aggressive animal",
+    },
+    // ── Linguistic (language, communication) ─────────────────────────────────────
+    {
+        taskId: "negotiate_treaty",
+        domain: "linguistic",
+        secondaryDomain: "interpersonal",
+        difficulty_Q: q(0.70),
+        timeBase_s: 1800, // 30 minutes
+        description: "Negotiate terms between conflicting parties",
+    },
+    {
+        taskId: "translate_foreign",
+        domain: "linguistic",
+        difficulty_Q: q(0.50),
+        timeBase_s: 3600, // 1 hour per page
+        requiredTool: "reference_texts",
+        description: "Translate unfamiliar language",
+    },
+    {
+        taskId: "command_formation",
+        domain: "linguistic",
+        difficulty_Q: q(0.40),
+        timeBase_s: 60, // 1 minute
+        description: "Issue clear commands to military formation",
+    },
+    // ── Interpersonal (teaching, leadership, empathy) ────────────────────────────
+    {
+        taskId: "teach_skill",
+        domain: "interpersonal",
+        difficulty_Q: q(0.45),
+        timeBase_s: 3600, // 1 hour lesson
+        description: "Teach specific skill to student",
+    },
+    {
+        taskId: "rally_troops",
+        domain: "interpersonal",
+        difficulty_Q: q(0.55),
+        timeBase_s: 300, // 5 minutes
+        description: "Rally frightened troops back to combat readiness",
+    },
+    {
+        taskId: "detect_deception",
+        domain: "interpersonal",
+        difficulty_Q: q(0.50),
+        timeBase_s: 60, // 1 minute during conversation
+        description: "Detect lies and falsehoods in conversation",
+    },
+    // ── Logical-Mathematical (engineering, planning, analysis) ────────────────────
+    {
+        taskId: "design_fortification",
+        domain: "logicalMathematical",
+        difficulty_Q: q(0.60),
+        timeBase_s: 86400, // 1 day
+        requiredTool: "drafting_tools",
+        description: "Engineer defensive fortification plans",
+    },
+    {
+        taskId: "design_siege_engine",
+        domain: "logicalMathematical",
+        difficulty_Q: q(0.75),
+        timeBase_s: 172800, // 2 days
+        requiredTool: "drafting_tools",
+        description: "Design complex siege machinery",
+    },
+    {
+        taskId: "solve_tactical_puzzle",
+        domain: "logicalMathematical",
+        difficulty_Q: q(0.55),
+        timeBase_s: 1800, // 30 minutes
+        description: "Analyze tactical situation and propose solution",
+    },
+    // ── Musical (performance, signaling) ─────────────────────────────────────────
+    {
+        taskId: "compose_march",
+        domain: "musical",
+        difficulty_Q: q(0.35),
+        timeBase_s: 1800, // 30 minutes
+        description: "Compose military marching cadence",
+    },
+    {
+        taskId: "perform_morale",
+        domain: "musical",
+        difficulty_Q: q(0.45),
+        timeBase_s: 1800, // 30 minutes performance
+        description: "Musical performance to boost morale",
+    },
+    {
+        taskId: "signal_formation",
+        domain: "musical",
+        difficulty_Q: q(0.30),
+        timeBase_s: 10, // 10 seconds
+        requiredTool: "signal_horn_or_drum",
+        description: "Signal formation maneuver via horn/drum",
+    },
+    // ── Intrapersonal (meditation, willpower) ────────────────────────────────────
+    {
+        taskId: "meditate_focus",
+        domain: "intrapersonal",
+        difficulty_Q: q(0.25),
+        timeBase_s: 1800, // 30 minutes
+        description: "Meditation to restore willpower",
+    },
+    {
+        taskId: "resist_temptation",
+        domain: "intrapersonal",
+        difficulty_Q: q(0.50),
+        timeBase_s: 60, // 1 minute decision point
+        description: "Resist immediate temptation for long-term gain",
+    },
+];
+// ── Exported Catalogue ───────────────────────────────────────────────────────
+/** Read-only catalogue of all competence tasks. */
+export const COMPETENCE_CATALOGUE = Object.freeze(entries);
+/** Lookup map for taskId → task. */
+export const COMPETENCE_TASK_BY_ID = new Map(entries.map((e) => [e.taskId, e]));
+/** Get a task by ID. Returns undefined if not found. */
+export function getTaskById(taskId) {
+    return COMPETENCE_TASK_BY_ID.get(taskId);
+}
+/** Check if a task exists in the catalogue. */
+export function hasTask(taskId) {
+    return COMPETENCE_TASK_BY_ID.has(taskId);
+}
+/** Get all tasks for a specific domain. */
+export function getTasksByDomain(domain) {
+    return entries.filter((t) => t.domain === domain || t.secondaryDomain === domain);
+}

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

@@ -0,0 +1,35 @@
+import type { Q } from "../units.js";
+import type { Entity } from "../sim/entity.js";
+export interface CraftingSpec {
+    outputId: string;
+    toolCategory?: "bladed" | "blunt" | "needlework" | "forge" | "precision";
+    /** Base seconds for a bodilyKinesthetic q(0.50) entity. */
+    baseTime_s: number;
+    /** Raw material quality 0–1 (Q-encoded). */
+    materialQ: Q;
+    /** Minimum bodilyKinesthetic required to attempt; below → success=false. */
+    minBKQ: Q;
+}
+export interface CraftingOutcome {
+    quality_Q: Q;
+    timeTaken_s: number;
+    success: boolean;
+    descriptor: "masterwork" | "fine" | "adequate" | "poor" | "ruined";
+}
+/**
+ * Resolve a crafting attempt.
+ *
+ * @param entity  - The crafter; uses `cognition.bodilyKinesthetic` and `control.fineControl`.
+ * @param spec    - Crafting specification.
+ * @param seed    - Deterministic seed (e.g. from eventSeed()).
+ */
+export declare function resolveCrafting(entity: Entity, spec: CraftingSpec, seed: number): CraftingOutcome;
+/**
+ * Phase 34: compute surgical precision multiplier from surgeon's bodilyKinesthetic.
+ * Result: lerp(q(0.70), q(1.30), bk)
+ *   - Assign to `TreatmentSchedule.surgicalPrecisionMul` in downtime config.
+ *   - BK q(0.00) → q(0.70)  (clumsy; slower/worse surgery)
+ *   - BK q(0.50) → q(1.00)  (normal)
+ *   - BK q(1.00) → q(1.30)  (expert; faster/better surgery)
+ */
+export declare function computeSurgicalPrecision(entity: Entity): Q;