@its-not-rocket-science/ananke 0.1.0

package/dist/src/competence/crafting.js

@@ -0,0 +1,88 @@
+// src/competence/crafting.ts — Phase 34: Bodily-Kinesthetic Non-Combat Applications
+//
+// Crafting quality model:
+//   quality_Q  = materialQ × bodilyKinesthetic × skillBonus × toolBonus  (± RNG variance)
+//   timeTaken_s = baseTime_s × q(0.50) / bodilyKinesthetic
+//     (baseTime_s is defined for a BK q(0.50) entity as the reference)
+//
+// No kernel import — pure resolution module.
+import { SCALE, q, clampQ, qMul, mulDiv } from "../units.js";
+import { makeRng } from "../rng.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+const TOOL_BONUS = {
+    precision: q(1.20),
+    bladed: q(1.10),
+    forge: q(1.10),
+    needlework: q(1.05),
+    blunt: q(1.05),
+};
+/** Half-width of RNG quality variance band. */
+const VARIANCE_HALF = q(0.10);
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function toDescriptor(quality_Q) {
+    if (quality_Q >= q(0.85))
+        return "masterwork";
+    if (quality_Q >= q(0.65))
+        return "fine";
+    if (quality_Q >= q(0.40))
+        return "adequate";
+    if (quality_Q >= q(0.20))
+        return "poor";
+    return "ruined";
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * 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 function resolveCrafting(entity, spec, seed) {
+    const bkQ = (entity.attributes.cognition?.bodilyKinesthetic ?? q(0.50));
+    // Minimum BK gate: not skilled enough to attempt this work
+    if (bkQ < spec.minBKQ) {
+        return {
+            quality_Q: q(0),
+            timeTaken_s: spec.baseTime_s,
+            success: false,
+            descriptor: "ruined",
+        };
+    }
+    // Tool bonus
+    const toolBonus = spec.toolCategory ? TOOL_BONUS[spec.toolCategory] : q(1.0);
+    // Skill bonus from fineControl: lerp(q(0.80), q(1.20), fineControl)
+    //   fineControl q(0.0)  → skillBonus q(0.80)  (no precision in hands)
+    //   fineControl q(0.50) → skillBonus q(1.00)  (neutral)
+    //   fineControl q(1.0)  → skillBonus q(1.20)  (exceptional fine motor control)
+    const fc = entity.attributes.control.fineControl;
+    const skillBonus = clampQ((q(0.80) + mulDiv(q(0.40), fc, SCALE.Q)), q(0.80), q(1.20));
+    // Expected quality = materialQ × bkQ × skillBonus × toolBonus (all Q-scaled)
+    const expected = qMul(qMul(spec.materialQ, bkQ), qMul(skillBonus, toolBonus));
+    // RNG variance ±VARIANCE_HALF (roll in [0, SCALE.Q-1], centered at SCALE.Q/2)
+    const rng = makeRng(seed, SCALE.Q);
+    const roll = rng.q01();
+    const variance = mulDiv(roll - SCALE.Q / 2, 2 * VARIANCE_HALF, SCALE.Q);
+    const quality_Q = clampQ((expected + variance), q(0), q(1.0));
+    // Time: baseTime_s is the reference at BK q(0.50); scales inversely with BK
+    const timeTaken_s = Math.round(spec.baseTime_s * q(0.50) / bkQ);
+    const success = quality_Q >= q(0.20);
+    return {
+        quality_Q,
+        timeTaken_s,
+        success,
+        descriptor: success ? toDescriptor(quality_Q) : "ruined",
+    };
+}
+/**
+ * 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 function computeSurgicalPrecision(entity) {
+    const bkQ = (entity.attributes.cognition?.bodilyKinesthetic ?? q(0.50));
+    return clampQ((q(0.70) + mulDiv(q(0.60), bkQ, SCALE.Q)), q(0.70), q(1.30));
+}

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

@@ -0,0 +1,53 @@
+import type { Q } from "../units.js";
+import type { Entity } from "../sim/entity.js";
+export interface EngineeringSpec {
+    /** Engineering category. */
+    category: "fortification" | "mechanism" | "weapon" | "vessel";
+    /** Complexity of the project (0–1). */
+    complexity_Q: Q;
+    /** Time budget in hours. */
+    timeBudget_h: number;
+}
+export interface EngineeringOutcome {
+    /** Quality multiplier on structural integrity / resist_J. */
+    qualityMul: Q;
+    /** True if project has a latent flaw. */
+    latentFlaw: boolean;
+    /** Time actually taken (may exceed budget if quality suffers). */
+    timeTaken_h: number;
+    /** Success descriptor. */
+    descriptor: "exceptional" | "good" | "adequate" | "poor" | "failure";
+}
+/**
+ * Resolve an engineering project.
+ *
+ * Formulas:
+ *   qualityMul = logicalMath × (1 − complexity_Q × 0.30) × timeFactor
+ *   P_latentFlaw = max(0, complexity_Q − logicalMath) × 0.40
+ *
+ * Troll (0.25) building complex siege engine → ~48% flaw chance. Heechee (0.95) → 0%.
+ *
+ * @param entity - The engineer; uses `cognition.logicalMathematical`.
+ * @param spec - Engineering specification.
+ * @param seed - Deterministic seed for RNG.
+ * @returns Engineering outcome.
+ */
+export declare function resolveEngineering(entity: Entity, spec: EngineeringSpec, seed: number): EngineeringOutcome;
+/**
+ * Compute structural integrity multiplier from engineering quality.
+ */
+export declare function applyEngineeringQuality(baseIntegrity: Q, qualityMul: Q): Q;
+/**
+ * Check if entity is qualified for an engineering project.
+ */
+export declare function isQualifiedEngineer(entity: Entity, minLogicalMath?: Q): boolean;
+/**
+ * Estimate project difficulty for an engineer.
+ * Returns estimated quality multiplier without consuming resources.
+ */
+export declare function estimateProjectQuality(entity: Entity, spec: Omit<EngineeringSpec, "timeBudget_h"> & {
+    timeBudget_h?: number;
+}): {
+    estimatedQuality_Q: Q;
+    flawRiskPercent: number;
+};

package/dist/src/competence/engineering.js

@@ -0,0 +1,108 @@
+// src/competence/engineering.ts — Phase 38: Engineering Quality (Logical-Mathematical Intelligence)
+//
+// Logical-mathematical intelligence governs systematic reasoning applied to complex
+// external problems: tactical analysis, engineering, research, resource planning.
+//
+// No kernel import — pure resolution module.
+import { SCALE, q, clampQ, mulDiv } from "../units.js";
+import { makeRng } from "../rng.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+/** Base quality multiplier at logicalMath q(0.50). */
+const BASE_QUALITY_MUL = q(0.70);
+/** Maximum quality multiplier. */
+const MAX_QUALITY_MUL = q(1.20);
+/** Minimum quality multiplier for success. */
+const MIN_SUCCESS_QUALITY = q(0.30);
+/** Time factor: rushed work reduces quality. */
+const TIME_FACTOR_BASE = 1.0;
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Resolve an engineering project.
+ *
+ * Formulas:
+ *   qualityMul = logicalMath × (1 − complexity_Q × 0.30) × timeFactor
+ *   P_latentFlaw = max(0, complexity_Q − logicalMath) × 0.40
+ *
+ * Troll (0.25) building complex siege engine → ~48% flaw chance. Heechee (0.95) → 0%.
+ *
+ * @param entity - The engineer; uses `cognition.logicalMathematical`.
+ * @param spec - Engineering specification.
+ * @param seed - Deterministic seed for RNG.
+ * @returns Engineering outcome.
+ */
+export function resolveEngineering(entity, spec, seed) {
+    const logicalMath = (entity.attributes.cognition?.logicalMathematical ?? q(0.50));
+    // Complexity penalty: higher complexity reduces base quality
+    const complexityPenalty = mulDiv(spec.complexity_Q, q(0.30), SCALE.Q);
+    const complexityMul = clampQ((SCALE.Q - complexityPenalty), q(0.40), SCALE.Q);
+    // Time factor: adequate time budget improves quality
+    // Optimal time = complexity × 10 hours baseline
+    const optimalTime_h = 5 + (spec.complexity_Q / SCALE.Q) * 15; // 5-20 hours based on complexity
+    const timeFactor = Math.min(1.2, spec.timeBudget_h / optimalTime_h);
+    // Calculate quality multiplier
+    const rawQuality = mulDiv(mulDiv(logicalMath, complexityMul, SCALE.Q), Math.round(timeFactor * SCALE.Q), SCALE.Q);
+    const qualityMul = clampQ((BASE_QUALITY_MUL + mulDiv(rawQuality, q(0.50), SCALE.Q)), q(0.20), MAX_QUALITY_MUL);
+    // Latent flaw probability
+    // P_flaw = max(0, complexity_Q − logicalMath) × 0.40
+    const skillDeficit = Math.max(0, spec.complexity_Q - logicalMath);
+    const pFlaw = mulDiv(skillDeficit, q(0.40), SCALE.Q);
+    // RNG for flaw check
+    const rng = makeRng(seed, SCALE.Q);
+    const flawRoll = rng.q01();
+    const latentFlaw = flawRoll < pFlaw;
+    // Determine descriptor
+    let descriptor;
+    if (qualityMul >= q(1.0)) {
+        descriptor = latentFlaw ? "good" : "exceptional";
+    }
+    else if (qualityMul >= q(0.70)) {
+        descriptor = "good";
+    }
+    else if (qualityMul >= MIN_SUCCESS_QUALITY) {
+        descriptor = "adequate";
+    }
+    else if (qualityMul >= q(0.15)) {
+        descriptor = "poor";
+    }
+    else {
+        descriptor = "failure";
+    }
+    // Time taken: may overrun if quality is poor
+    const timeTaken_h = descriptor === "poor"
+        ? Math.round(spec.timeBudget_h * 1.5)
+        : spec.timeBudget_h;
+    return { qualityMul, latentFlaw, timeTaken_h, descriptor };
+}
+/**
+ * Compute structural integrity multiplier from engineering quality.
+ */
+export function applyEngineeringQuality(baseIntegrity, qualityMul) {
+    return clampQ(mulDiv(baseIntegrity, qualityMul, SCALE.Q), q(0.30), SCALE.Q);
+}
+/**
+ * Check if entity is qualified for an engineering project.
+ */
+export function isQualifiedEngineer(entity, minLogicalMath = q(0.40)) {
+    const logicalMath = (entity.attributes.cognition?.logicalMathematical ?? q(0.50));
+    return logicalMath >= minLogicalMath;
+}
+/**
+ * Estimate project difficulty for an engineer.
+ * Returns estimated quality multiplier without consuming resources.
+ */
+export function estimateProjectQuality(entity, spec) {
+    const logicalMath = (entity.attributes.cognition?.logicalMathematical ?? q(0.50));
+    // Simplified quality estimate
+    const complexityPenalty = mulDiv(spec.complexity_Q, q(0.30), SCALE.Q);
+    const complexityMul = clampQ((SCALE.Q - complexityPenalty), q(0.40), SCALE.Q);
+    const timeBudget = spec.timeBudget_h ?? 10;
+    const optimalTime_h = 5 + (spec.complexity_Q / SCALE.Q) * 15;
+    const timeFactor = Math.min(1.2, timeBudget / optimalTime_h);
+    const rawQuality = mulDiv(mulDiv(logicalMath, complexityMul, SCALE.Q), Math.round(timeFactor * SCALE.Q), SCALE.Q);
+    const estimatedQuality_Q = clampQ((BASE_QUALITY_MUL + mulDiv(rawQuality, q(0.50), SCALE.Q)), q(0.20), MAX_QUALITY_MUL);
+    // Flaw risk
+    const skillDeficit = Math.max(0, spec.complexity_Q - logicalMath);
+    const pFlaw = mulDiv(skillDeficit, q(0.40), SCALE.Q);
+    const flawRiskPercent = Math.round((pFlaw / SCALE.Q) * 100);
+    return { estimatedQuality_Q, flawRiskPercent };
+}

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

@@ -0,0 +1,68 @@
+import type { Q } from "../units.js";
+import type { Entity } from "../sim/entity.js";
+import type { WorldState } from "../sim/world.js";
+import type { CompetenceDomain } from "./catalogue.js";
+/** A competence action to be resolved. */
+export interface CompetenceAction {
+    /** Primary competence domain. */
+    domain: CompetenceDomain;
+    /** Task identifier (references CompetenceCatalogue). */
+    taskId: string;
+    /** Target entity ID (for interpersonal / inter-species tasks). */
+    targetEntityId?: number;
+    /** Tool/equipment item used. */
+    toolId?: string;
+    /** Time available for the task in seconds. */
+    timeAvailable_s: number;
+    /** Deterministic seed for RNG. */
+    seed: number;
+    /** Terrain/biome context for environmental tasks. */
+    terrain?: string;
+    /** Whether to include narrative description in outcome. */
+    narrative?: boolean;
+}
+/** Outcome of a competence action resolution. */
+export interface CompetenceOutcome {
+    /** Domain that was resolved. */
+    domain: CompetenceDomain;
+    /** Quality of the outcome (0–1). */
+    quality_Q: Q;
+    /** Time actually taken in seconds. */
+    timeTaken_s: number;
+    /** Whether the task succeeded. */
+    success: boolean;
+    /** Outcome descriptor. */
+    descriptor: "exceptional" | "good" | "adequate" | "poor" | "failure";
+    /** XP gained from this attempt (fed into Phase 21). */
+    xpGained: number;
+    /** Optional narrative description of outcome. */
+    narrativeLine?: string | undefined;
+    /** Domain-specific result data. */
+    details?: unknown;
+}
+/**
+ * Map domain-specific descriptors to canonical descriptors.
+ */
+declare function canonicalizeDescriptor(descriptor: string): CompetenceOutcome["descriptor"];
+/**
+ * Calculate XP gain based on outcome.
+ */
+declare function calculateXP(descriptor: CompetenceOutcome["descriptor"], difficulty_Q: Q): number;
+/**
+ * Get the relevant cognitive attribute for a domain.
+ */
+declare function getDomainIntelligence(entity: Entity, domain: CompetenceDomain): Q;
+/**
+ * Resolve a competence action.
+ *
+ * This is the main entry point for the Phase 40 competence framework.
+ * It routes to the appropriate domain-specific resolver and computes
+ * XP gain for Phase 21 integration.
+ *
+ * @param actor - The entity performing the action.
+ * @param action - The competence action specification.
+ * @param world - The world state (for finding targets, etc.).
+ * @returns Competence outcome with quality, XP, and narrative.
+ */
+export declare function resolveCompetence(actor: Entity, action: CompetenceAction, world: WorldState): CompetenceOutcome;
+export { getDomainIntelligence, canonicalizeDescriptor, calculateXP };