@its-not-rocket-science/ananke 0.1.0

package/dist/src/describe.js

@@ -0,0 +1,276 @@
+import { SCALE } from "./units.js";
+// breaks = [t1_max, t2_max, t3_max, t4_max, t5_max]
+// value < breaks[0] → tier 1, …, value >= breaks[4] → tier 6
+function rateTier(value, breaks) {
+    if (value < breaks[0])
+        return 1;
+    if (value < breaks[1])
+        return 2;
+    if (value < breaks[2])
+        return 3;
+    if (value < breaks[3])
+        return 4;
+    if (value < breaks[4])
+        return 5;
+    return 6;
+}
+// For inverted attrs (lower = better)
+// breaks = [t6_max, t5_max, t4_max, t3_max, t2_max] (ascending)
+// value < breaks[0] → tier 6, …, value >= breaks[4] → tier 1
+function rateInverted(value, breaks) {
+    if (value < breaks[0])
+        return 6;
+    if (value < breaks[1])
+        return 5;
+    if (value < breaks[2])
+        return 4;
+    if (value < breaks[3])
+        return 3;
+    if (value < breaks[4])
+        return 2;
+    return 1;
+}
+// Breakpoints in fixed-point units
+// peakForce_N: fp = N * SCALE.N (100) — tiers at 500/1100/2000/3500/5500 N
+const FORCE_BREAKS = [50_000, 110_000, 200_000, 350_000, 550_000];
+// peakPower_W: SCALE.W=1 — tiers at 400/800/1400/2000/3000 W
+const POWER_BREAKS = [400, 800, 1_400, 2_000, 3_000];
+// continuousPower_W — tiers at 80/150/260/380/600 W
+const CONT_BREAKS = [80, 150, 260, 380, 600];
+// reserveEnergy_J: SCALE.J=1 — tiers at 8/15/23/38/58 kJ
+const ENERGY_BREAKS = [8_000, 15_000, 23_000, 38_000, 58_000];
+// reactionTime_s (inverted): SCALE.s=10000 — ascending [t6_max…t2_max] in fp
+// tiers (seconds): <0.12 | 0.12–0.17 | 0.17–0.22 | 0.22–0.30 | 0.30–0.45 | >0.45
+const REACT_BREAKS = [1_200, 1_700, 2_200, 3_000, 4_500];
+// Q attrs 0–1 (controlQuality, stability, fineControl): SCALE.Q=10000
+// tiers: <0.35 | 0.35–0.58 | 0.58–0.78 | 0.78–0.87 | 0.87–0.93 | >0.93
+const Q_BREAKS = [3_500, 5_800, 7_800, 8_700, 9_300];
+// resilience Q attrs (distressTolerance, shockTolerance, concussionTolerance)
+// tiers: <0.25 | 0.25–0.45 | 0.45–0.62 | 0.62–0.75 | 0.75–0.88 | >0.88
+const RES_BREAKS = [2_500, 4_500, 6_200, 7_500, 8_800];
+// decisionLatency_s (inverted): SCALE.s=10000 — ascending [t6_max…t2_max] in fp
+// tiers (seconds): <0.08 | 0.08–0.30 | 0.30–0.46 | 0.46–0.56 | 0.56–0.80 | >0.80
+const DECISION_BREAKS = [800, 3_000, 4_600, 5_600, 8_000];
+// Labels indexed by (tier - 1)
+const PERF_LABELS = ["feeble", "weak", "average", "strong", "excellent", "exceptional"];
+const SPEED_LABELS = ["sluggish", "slow", "average", "quick", "fast", "instant"];
+const CTRL_LABELS = ["erratic", "poor", "average", "precise", "refined", "masterful"];
+const RES_LABELS = ["fragile", "low", "average", "resilient", "tough", "ironclad"];
+const COG_LABELS = ["sluggish", "slow", "average", "sharp", "razor-sharp", "machine-like"];
+const FORCE_COMPARISONS = [
+    "weaker than most children",
+    "sedentary adult — below average output",
+    "average adult — baseline human force",
+    "trained athlete or competitive fighter",
+    "elite level — professional fighter strength",
+    "superhuman or powered — beyond biological norms",
+];
+const POWER_COMPARISONS = [
+    "minimal power output",
+    "below average explosive output",
+    "moderate explosive output",
+    "strong explosive performance",
+    "elite explosive output",
+    "extreme power — mechanical or enhanced",
+];
+const CONT_COMPARISONS = [
+    "very limited aerobic capacity",
+    "below average aerobic output",
+    "sustainable aerobic output",
+    "strong sustained performance",
+    "elite endurance athlete level",
+    "extraordinary sustained output",
+];
+const ENERGY_COMPARISONS = [
+    "very low energy reserves",
+    "below average combat stamina",
+    "typical combat energy reserves",
+    "good combat energy reserves",
+    "exceptional energy reserves",
+    "extraordinary — far beyond normal capacity",
+];
+const REACT_COMPARISONS = [
+    "very slow reflexes",
+    "below average response time",
+    "average adult response time",
+    "trained athlete response time",
+    "elite combat reflexes",
+    "machine-speed response",
+];
+const CTRL_COMPARISONS = [
+    "very poor motor control",
+    "below average movement quality",
+    "competent general movement",
+    "skilled coordinated movement",
+    "highly refined motor control",
+    "near-perfect motor precision",
+];
+const STABILITY_COMPARISONS = [
+    "very poor balance",
+    "below average stability",
+    "normal postural stability",
+    "good balance and stability",
+    "excellent balance and body control",
+    "extraordinary stability",
+];
+const FINE_COMPARISONS = [
+    "very clumsy fine motor",
+    "below average manual dexterity",
+    "everyday manual dexterity",
+    "skilled fine motor control",
+    "exceptional precision",
+    "near-surgical precision",
+];
+const PAIN_COMPARISONS = [
+    "extremely pain-sensitive",
+    "below average pain threshold",
+    "typical distress threshold",
+    "trained pain tolerance",
+    "high pain threshold",
+    "extreme pain suppression",
+];
+const SHOCK_COMPARISONS = [
+    "very fragile to shock",
+    "below average shock resistance",
+    "normal shock resistance",
+    "trained shock absorption",
+    "high shock resistance",
+    "extreme shock tolerance",
+];
+const CONC_COMPARISONS = [
+    "very vulnerable to head trauma",
+    "below average concussion resistance",
+    "standard skull protection",
+    "above average head protection",
+    "high concussion resistance",
+    "exceptional — distributed or no central brain",
+];
+const DECISION_COMPARISONS = [
+    "extremely slow decision making",
+    "slow tactical processing",
+    "normal human deliberation time",
+    "quick tactical processing",
+    "fast tactical decisions",
+    "machine-speed decision making",
+];
+// Value formatters
+function fmtN(fp) { return `${Math.round(fp / SCALE.N)} N`; }
+function fmtW(fp) { return `${fp} W`; }
+function fmtJ(fp) { return fp >= 1000 ? `${(fp / 1000).toFixed(0)} kJ` : `${fp} J`; }
+function fmtMs(fp) { return `${Math.round((fp / SCALE.s) * 1000)} ms`; }
+function fmtQ(fp) { return `${(fp / SCALE.Q).toFixed(2)}`; }
+function fmtM(fp) { return `${(fp / SCALE.m).toFixed(2)} m`; }
+function fmtKg(fp) { return `${(fp / SCALE.kg).toFixed(1)} kg`; }
+function makeRating(tier, labels, comparisons, value) {
+    return {
+        tier,
+        label: labels[tier - 1] ?? "",
+        comparison: comparisons[tier - 1] ?? "",
+        value,
+    };
+}
+function describeStature(fp) {
+    let label;
+    if (fp < 14_000)
+        label = "very short";
+    else if (fp <= 16_000)
+        label = "short";
+    else if (fp < 18_000)
+        label = "average height";
+    else if (fp < 19_500)
+        label = "tall";
+    else
+        label = "very tall";
+    return `${fmtM(fp)} — ${label}`;
+}
+function describeMass(fp) {
+    let label;
+    if (fp < 50_000)
+        label = "slight build";
+    else if (fp < 65_000)
+        label = "lean build";
+    else if (fp < 90_000)
+        label = "average build";
+    else if (fp < 115_000)
+        label = "heavy build";
+    else
+        label = "very heavy build";
+    return `${fmtKg(fp)} — ${label}`;
+}
+export function describeCharacter(attrs) {
+    const { morphology, performance, control, resilience, perception } = attrs;
+    const strengthTier = rateTier(performance.peakForce_N, FORCE_BREAKS);
+    const powerTier = rateTier(performance.peakPower_W, POWER_BREAKS);
+    const endTier = rateTier(performance.continuousPower_W, CONT_BREAKS);
+    const stamTier = rateTier(performance.reserveEnergy_J, ENERGY_BREAKS);
+    const reactTier = rateInverted(control.reactionTime_s, REACT_BREAKS);
+    const coordTier = rateTier(control.controlQuality, Q_BREAKS);
+    const balTier = rateTier(control.stability, Q_BREAKS);
+    const precTier = rateTier(control.fineControl, Q_BREAKS);
+    const painTier = rateTier(resilience.distressTolerance, RES_BREAKS);
+    const toughTier = rateTier(resilience.shockTolerance, RES_BREAKS);
+    const concTier = rateTier(resilience.concussionTolerance, RES_BREAKS);
+    const decTier = rateInverted(perception?.decisionLatency_s ?? 0, DECISION_BREAKS);
+    return {
+        stature: describeStature(morphology.stature_m),
+        mass: describeMass(morphology.mass_kg),
+        strength: makeRating(strengthTier, PERF_LABELS, FORCE_COMPARISONS, fmtN(performance.peakForce_N)),
+        explosivePower: makeRating(powerTier, PERF_LABELS, POWER_COMPARISONS, fmtW(performance.peakPower_W)),
+        endurance: makeRating(endTier, PERF_LABELS, CONT_COMPARISONS, fmtW(performance.continuousPower_W)),
+        stamina: makeRating(stamTier, PERF_LABELS, ENERGY_COMPARISONS, fmtJ(performance.reserveEnergy_J)),
+        reactionTime: makeRating(reactTier, SPEED_LABELS, REACT_COMPARISONS, fmtMs(control.reactionTime_s)),
+        coordination: makeRating(coordTier, CTRL_LABELS, CTRL_COMPARISONS, fmtQ(control.controlQuality)),
+        balance: makeRating(balTier, CTRL_LABELS, STABILITY_COMPARISONS, fmtQ(control.stability)),
+        precision: makeRating(precTier, CTRL_LABELS, FINE_COMPARISONS, fmtQ(control.fineControl)),
+        painTolerance: makeRating(painTier, RES_LABELS, PAIN_COMPARISONS, fmtQ(resilience.distressTolerance)),
+        toughness: makeRating(toughTier, RES_LABELS, SHOCK_COMPARISONS, fmtQ(resilience.shockTolerance)),
+        concussionResistance: makeRating(concTier, RES_LABELS, CONC_COMPARISONS, fmtQ(resilience.concussionTolerance)),
+        visionRange: `${Math.round((perception?.visionRange_m ?? 0) / SCALE.m)} m, ${perception?.visionArcDeg ?? 0}\u00b0 arc`,
+        hearingRange: `${Math.round((perception?.hearingRange_m ?? 0) / SCALE.m)} m`,
+        decisionSpeed: makeRating(decTier, COG_LABELS, DECISION_COMPARISONS, fmtMs(perception?.decisionLatency_s ?? 0)),
+    };
+}
+function pad(s, width) {
+    return s.length >= width ? s : s + " ".repeat(width - s.length);
+}
+export function formatCharacterSheet(desc) {
+    const row = (name, r) => `  ${pad(name + ":", 14)}${pad(r.value, 12)} [${r.label}]    ${r.comparison}`;
+    return [
+        "Body",
+        `  Stature:      ${desc.stature}`,
+        `  Mass:         ${desc.mass}`,
+        "",
+        "Performance",
+        row("Strength", desc.strength),
+        row("Power", desc.explosivePower),
+        row("Endurance", desc.endurance),
+        row("Stamina", desc.stamina),
+        "",
+        "Control",
+        row("Reaction", desc.reactionTime),
+        row("Coordination", desc.coordination),
+        row("Balance", desc.balance),
+        row("Precision", desc.precision),
+        "",
+        "Resilience",
+        row("Pain", desc.painTolerance),
+        row("Toughness", desc.toughness),
+        row("Concussion", desc.concussionResistance),
+        "",
+        "Perception",
+        `  Vision:       ${desc.visionRange}`,
+        `  Hearing:      ${desc.hearingRange}`,
+        row("Decision", desc.decisionSpeed),
+    ].join("\n");
+}
+export function formatOneLine(desc) {
+    const statureParts = desc.stature.split(" — ");
+    const statureM = statureParts[0] ?? desc.stature;
+    const statureLbl = statureParts[1] ?? "";
+    const capLbl = statureLbl.charAt(0).toUpperCase() + statureLbl.slice(1);
+    const massKg = desc.mass.split(" — ")[0] ?? desc.mass;
+    return (`${capLbl} (${statureM}), ${massKg}; ` +
+        `strength ${desc.strength.label} (${desc.strength.value}), ` +
+        `reaction ${desc.reactionTime.label} (${desc.reactionTime.value}), ` +
+        `resilience ${desc.painTolerance.label}.`);
+}

package/dist/src/dialogue.d.ts

@@ -0,0 +1,122 @@
+import type { Q } from "./units.js";
+import type { Entity } from "./sim/entity.js";
+import type { NarrativeConfig } from "./narrative.js";
+/** A lightweight trade item for negotiation offers. Full item economy is Phase 25. */
+export interface TradeItem {
+    id: string;
+    value: number;
+}
+/** A proposed exchange: initiator gives items and receives items in return. */
+export interface TradeOffer {
+    giving: TradeItem[];
+    receiving: TradeItem[];
+}
+/** All possible social actions an entity can take. */
+export type DialogueAction = {
+    kind: "intimidate";
+    intensity_Q: Q;
+} | {
+    kind: "persuade";
+    argument?: string;
+} | {
+    kind: "deceive";
+    plausibility_Q: Q;
+} | {
+    kind: "surrender";
+    terms?: string;
+} | {
+    kind: "negotiate";
+    offer: TradeOffer;
+} | {
+    kind: "signal";
+    targetSpecies: string;
+    intent: "calm" | "submit" | "ally" | "territory";
+};
+/** The resolution result of a dialogue action. */
+export type DialogueOutcome = {
+    result: "success";
+    moraleDelta?: Q;
+    fearDelta?: Q;
+    setSurrendered?: boolean;
+    comprehension_Q?: Q;
+} | {
+    result: "failure";
+    cooldown_s: number;
+    aggravated?: boolean;
+} | {
+    result: "escalate";
+};
+/**
+ * Context for a dialogue resolution.
+ *
+ * `sharedFaction` — Phase 24 placeholder; set to true when entities share a faction.
+ * `priorFailedAttempts` — cumulative failed persuasion attempts by this initiator against
+ *   this target; each one imposes a PERSUADE_FAILURE_PENALTY.
+ */
+export interface DialogueContext {
+    initiator: Entity;
+    target: Entity;
+    worldSeed: number;
+    tick: number;
+    sharedFaction?: boolean;
+    priorFailedAttempts?: number;
+}
+/** Reduction to intimidation probability when target has the "leader" trait. */
+export declare const LEADER_INTIMIDATE_REDUCTION: Q;
+/** Base success probability for an unmodified persuade attempt. */
+export declare const PERSUADE_BASE: Q;
+/** Persuasion bonus when initiator and target share a faction (Phase 24). */
+export declare const PERSUADE_FACTION_BONUS: Q;
+/** Persuasion penalty per prior failed attempt against this target. */
+export declare const PERSUADE_FAILURE_PENALTY: Q;
+/** Fear increase applied to target when intimidation succeeds. */
+export declare const INTIMIDATE_FEAR_DELTA: Q;
+/** Minimum fearQ for target to consider accepting surrender. Below this = always refuses. */
+export declare const SURRENDER_THRESHOLD: Q;
+/**
+ * If intimidation *fails* and target's fearQ is below this value,
+ * the target interprets the attempt as an insult and escalates.
+ */
+export declare const ESCALATE_THRESHOLD: Q;
+/**
+ * Compute the success probability for a dialogue action without rolling RNG.
+ *
+ * Exported so tests can assert on exact probability values without seeding concerns.
+ * For "escalate" scenarios the probability returned is the *intimidation* probability;
+ * escalation is a post-failure branch, not a separate probability.
+ */
+export declare function dialogueProbability(action: DialogueAction, ctx: DialogueContext): Q;
+/**
+ * Resolve a dialogue action and return the outcome.
+ *
+ * - Intimidate, persuade, and deceive use seeded RNG.
+ * - Surrender is deterministic: succeeds if target.fearQ > SURRENDER_THRESHOLD.
+ * - Negotiate is deterministic: succeeds if trade utility is positive for the target.
+ *
+ * @returns A DialogueOutcome.  Use `applyDialogueOutcome` to write deltas back to entities.
+ */
+export declare function resolveDialogue(action: DialogueAction, ctx: DialogueContext): DialogueOutcome;
+/**
+ * Write a successful outcome's deltas back to the target entity.
+ *
+ * - `fearDelta`  — added directly to `target.condition.fearQ` (positive = more fear).
+ * - `moraleDelta` — subtracted from `target.condition.fearQ` (positive morale = less fear).
+ * - `setSurrendered` — sets `target.condition.surrendered = true`.
+ *
+ * No-op if `outcome.result !== "success"`.
+ */
+export declare function applyDialogueOutcome(outcome: DialogueOutcome, target: Entity): void;
+/**
+ * Produce a human-readable description of a dialogue action and its outcome.
+ *
+ * Verbosity levels:
+ * - `terse`   — single word label + result token  (shortest)
+ * - `normal`  — one sentence with action and outcome context
+ * - `verbose` — entity names + extended description of what happened
+ *
+ * @param ids — optional initiator/target entity ids used to resolve names from `cfg.nameMap`
+ */
+export declare function narrateDialogue(action: DialogueAction, outcome: DialogueOutcome, cfg: NarrativeConfig, ids?: {
+    initiatorId?: number;
+    targetId?: number;
+}): string;

package/dist/src/dialogue.js

@@ -0,0 +1,266 @@
+// src/dialogue.ts — Phase 23: Dialogue & Negotiation Layer
+//
+// Non-combat resolution grounded in the same physical and psychological
+// attributes as the combat engine.  No arbitrary Charisma stats —
+// intimidation strength comes from peakForce_N, persuasion from cognition,
+// deception is defeated by attentionDepth.
+//
+// No kernel import — pure data-resolution module.
+import { SCALE, q, clampQ, qMul, mulDiv, to } from "./units.js";
+import { eventSeed } from "./sim/seeds.js";
+import { makeRng } from "./rng.js";
+import { resolveSignal } from "./competence/interspecies.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+/** Real-newton threshold where intimidation force factor reaches q(1.0). */
+const INTIMIDATE_FORCE_SCALE = to.N(4000);
+/** Reduction to intimidation probability when target has the "leader" trait. */
+export const LEADER_INTIMIDATE_REDUCTION = q(0.15);
+/** Base success probability for an unmodified persuade attempt. */
+export const PERSUADE_BASE = q(0.40);
+/** Persuasion bonus when initiator and target share a faction (Phase 24). */
+export const PERSUADE_FACTION_BONUS = q(0.10);
+/** Persuasion penalty per prior failed attempt against this target. */
+export const PERSUADE_FAILURE_PENALTY = q(0.10);
+/** Fear increase applied to target when intimidation succeeds. */
+export const INTIMIDATE_FEAR_DELTA = q(0.15);
+/** Minimum fearQ for target to consider accepting surrender. Below this = always refuses. */
+export const SURRENDER_THRESHOLD = q(0.40);
+/**
+ * If intimidation *fails* and target's fearQ is below this value,
+ * the target interprets the attempt as an insult and escalates.
+ */
+export const ESCALATE_THRESHOLD = q(0.20);
+// ── RNG salts ─────────────────────────────────────────────────────────────────
+const SALT_INTIMIDATE = 0xD1A100;
+const SALT_PERSUADE = 0xD1A101;
+const SALT_DECEIVE = 0xD1A102;
+const SALT_SIGNAL = 0xD1A103; // Phase 36: cross-species signaling
+// ── Internal helpers ──────────────────────────────────────────────────────────
+/**
+ * Convert a fixed-point force (SCALE.N units) to a Q fraction in [0, 1].
+ * q(1.0) corresponds to INTIMIDATE_FORCE_SCALE (4000 N real).
+ */
+function forceToQ(peakForce_N) {
+    return clampQ(mulDiv(peakForce_N, SCALE.Q, INTIMIDATE_FORCE_SCALE), 0, SCALE.Q);
+}
+/**
+ * Convert an integer `attentionDepth` to a Q fraction in [0, 1].
+ * Human baseline (4) → q(0.40); robot / sharp mind (10) → q(1.0).
+ */
+function attentionDepthQ(depth) {
+    return clampQ(Math.trunc((depth * SCALE.Q) / 10), 0, SCALE.Q);
+}
+/**
+ * Learning rate bonus for persuasion derived from attentionDepth.
+ * +250 per point above the human baseline of 4, capped at q(0.20).
+ */
+function learningBonus(attentionDepth) {
+    return clampQ(Math.max(0, attentionDepth - 4) * 250, 0, q(0.20));
+}
+// ── Probability computation ───────────────────────────────────────────────────
+/**
+ * Compute the success probability for a dialogue action without rolling RNG.
+ *
+ * Exported so tests can assert on exact probability values without seeding concerns.
+ * For "escalate" scenarios the probability returned is the *intimidation* probability;
+ * escalation is a post-failure branch, not a separate probability.
+ */
+export function dialogueProbability(action, ctx) {
+    const { initiator, target } = ctx;
+    switch (action.kind) {
+        case "intimidate": {
+            const forceFrac = forceToQ(initiator.attributes.performance.peakForce_N);
+            const leaderRed = target.traits.includes("leader") ? LEADER_INTIMIDATE_REDUCTION : 0;
+            return clampQ(forceFrac
+                + target.condition.fearQ
+                - target.attributes.resilience.distressTolerance
+                - leaderRed, 0, SCALE.Q);
+        }
+        case "persuade": {
+            const failed = ctx.priorFailedAttempts ?? 0;
+            // Phase 33: linguistic intelligence sets per-entity persuasion base
+            // Formula: q(0.20) + linguistic × q(0.30); human (0.65) → q(0.395); elf (0.80) → q(0.44)
+            const linguisticQ = initiator.attributes.cognition?.linguistic;
+            const dynamicBase = linguisticQ !== undefined
+                ? clampQ((q(0.20) + mulDiv(q(0.30), linguisticQ, SCALE.Q)), q(0.20), q(0.50))
+                : PERSUADE_BASE;
+            return clampQ(dynamicBase
+                + learningBonus(target.attributes.perception?.attentionDepth ?? 0)
+                + (ctx.sharedFaction ? PERSUADE_FACTION_BONUS : 0)
+                - (failed * PERSUADE_FAILURE_PENALTY), 0, SCALE.Q);
+        }
+        case "deceive": {
+            // Phase 37: deception detection uses both attentionDepth AND interpersonal
+            // P_success = plausibility × (1 - attentionDepth) × (1 - interpersonal × 0.50)
+            const attentionFactor = (SCALE.Q - attentionDepthQ(target.attributes.perception?.attentionDepth ?? 0));
+            // Interpersonal gives defensive bonus against deception
+            const interpersonal = (target.attributes.cognition?.interpersonal ?? q(0.50));
+            const interpersonalFactor = clampQ((SCALE.Q - mulDiv(interpersonal, q(0.50), SCALE.Q)), q(0.50), SCALE.Q);
+            return qMul(qMul(action.plausibility_Q, attentionFactor), interpersonalFactor);
+        }
+        case "surrender":
+            // Returns non-zero only when target's fear exceeds the acceptance threshold.
+            return clampQ(target.condition.fearQ - SURRENDER_THRESHOLD, 0, SCALE.Q);
+        case "negotiate": {
+            const given = action.offer.giving.reduce((s, i) => s + i.value, 0);
+            const received = action.offer.receiving.reduce((s, i) => s + i.value, 0);
+            return given > received ? SCALE.Q : 0;
+        }
+        case "signal":
+            // Phase 36: signal probability is computed in resolveSignal; here we return a placeholder
+            // The actual resolution uses the interspecies resolver
+            return q(0.50);
+    }
+}
+// ── Resolution ────────────────────────────────────────────────────────────────
+/**
+ * Resolve a dialogue action and return the outcome.
+ *
+ * - Intimidate, persuade, and deceive use seeded RNG.
+ * - Surrender is deterministic: succeeds if target.fearQ > SURRENDER_THRESHOLD.
+ * - Negotiate is deterministic: succeeds if trade utility is positive for the target.
+ *
+ * @returns A DialogueOutcome.  Use `applyDialogueOutcome` to write deltas back to entities.
+ */
+export function resolveDialogue(action, ctx) {
+    const P = dialogueProbability(action, ctx);
+    // Deterministic branches
+    if (action.kind === "surrender") {
+        if (P > 0)
+            return { result: "success", setSurrendered: true };
+        return { result: "failure", cooldown_s: 0 };
+    }
+    if (action.kind === "negotiate") {
+        return P > 0
+            ? { result: "success" }
+            : { result: "failure", cooldown_s: 0 };
+    }
+    // Phase 36: Signal action uses interspecies resolver
+    if (action.kind === "signal") {
+        const seed = eventSeed(ctx.worldSeed, ctx.tick, ctx.initiator.id, ctx.target.id, SALT_SIGNAL);
+        const signalOutcome = resolveSignal(ctx.initiator, {
+            targetSpecies: action.targetSpecies,
+            intent: action.intent,
+            targetFearQ: ctx.target.condition.fearQ ?? q(0),
+        }, seed);
+        if (signalOutcome.success) {
+            return { result: "success", comprehension_Q: signalOutcome.comprehension_Q };
+        }
+        return { result: "failure", cooldown_s: 45, aggravated: signalOutcome.aggravated };
+    }
+    // RNG-based branches (intimidate, persuade, deceive)
+    const salt = action.kind === "intimidate" ? SALT_INTIMIDATE
+        : action.kind === "persuade" ? SALT_PERSUADE
+            : SALT_DECEIVE;
+    const seed = eventSeed(ctx.worldSeed, ctx.tick, ctx.initiator.id, ctx.target.id, salt);
+    const rng = makeRng(seed, SCALE.Q);
+    if (rng.q01() < P) {
+        if (action.kind === "intimidate") {
+            return { result: "success", fearDelta: INTIMIDATE_FEAR_DELTA };
+        }
+        return { result: "success" };
+    }
+    // Failure branches
+    if (action.kind === "intimidate") {
+        // Fearless targets interpret intimidation as an insult.
+        if (ctx.target.condition.fearQ < ESCALATE_THRESHOLD) {
+            return { result: "escalate" };
+        }
+        return { result: "failure", cooldown_s: 30 };
+    }
+    const cooldown = action.kind === "persuade" ? 60 : 120;
+    return { result: "failure", cooldown_s: cooldown };
+}
+// ── Outcome application ───────────────────────────────────────────────────────
+/**
+ * Write a successful outcome's deltas back to the target entity.
+ *
+ * - `fearDelta`  — added directly to `target.condition.fearQ` (positive = more fear).
+ * - `moraleDelta` — subtracted from `target.condition.fearQ` (positive morale = less fear).
+ * - `setSurrendered` — sets `target.condition.surrendered = true`.
+ *
+ * No-op if `outcome.result !== "success"`.
+ */
+export function applyDialogueOutcome(outcome, target) {
+    if (outcome.result !== "success")
+        return;
+    if (outcome.fearDelta !== undefined) {
+        target.condition.fearQ = clampQ(target.condition.fearQ + outcome.fearDelta, 0, SCALE.Q);
+    }
+    if (outcome.moraleDelta !== undefined) {
+        target.condition.fearQ = clampQ(target.condition.fearQ - outcome.moraleDelta, 0, SCALE.Q);
+    }
+    if (outcome.setSurrendered) {
+        target.condition.surrendered = true;
+    }
+}
+// ── Narrative ─────────────────────────────────────────────────────────────────
+/** Short display label per action kind. */
+function actionLabel(action) {
+    switch (action.kind) {
+        case "intimidate": return "Intimidation";
+        case "persuade": return "Persuasion";
+        case "deceive": return "Deception";
+        case "surrender": return "Surrender demand";
+        case "negotiate": return "Negotiation";
+        case "signal": return "Cross-species signal";
+    }
+}
+/** Extended description for verbose mode. */
+function verboseDetail(action, outcome) {
+    const res = outcome.result;
+    switch (action.kind) {
+        case "intimidate":
+            return res === "success" ? "the target was cowed by the show of force"
+                : res === "escalate" ? "the fearless target took it as an insult and attacked"
+                    : "the target stood firm and was not intimidated";
+        case "persuade":
+            return res === "success" ? "the argument was accepted after careful consideration"
+                : "the target remained unconvinced";
+        case "deceive":
+            return res === "success" ? "the false claim was believed"
+                : "the target detected the deception";
+        case "surrender":
+            return res === "success" ? "the target laid down arms"
+                : "the target refused to surrender";
+        case "negotiate":
+            return res === "success" ? "both parties agreed to the exchange"
+                : "the offer was rejected as unfavourable";
+        case "signal":
+            return res === "success" ? `the ${action.targetSpecies} understood the ${action.intent} signal`
+                : res === "failure" && outcome.aggravated ? `the ${action.targetSpecies} was aggravated by the signal`
+                    : `the ${action.targetSpecies} did not comprehend the signal`;
+    }
+}
+/**
+ * Produce a human-readable description of a dialogue action and its outcome.
+ *
+ * Verbosity levels:
+ * - `terse`   — single word label + result token  (shortest)
+ * - `normal`  — one sentence with action and outcome context
+ * - `verbose` — entity names + extended description of what happened
+ *
+ * @param ids — optional initiator/target entity ids used to resolve names from `cfg.nameMap`
+ */
+export function narrateDialogue(action, outcome, cfg, ids) {
+    const label = actionLabel(action);
+    const res = outcome.result;
+    if (cfg.verbosity === "terse") {
+        return `${label}: ${res}`;
+    }
+    const iName = ids?.initiatorId !== undefined
+        ? (cfg.nameMap?.get(ids.initiatorId) ?? `entity ${ids.initiatorId}`)
+        : "the initiator";
+    const tName = ids?.targetId !== undefined
+        ? (cfg.nameMap?.get(ids.targetId) ?? `entity ${ids.targetId}`)
+        : "the target";
+    if (cfg.verbosity === "normal") {
+        const resultPhrase = res === "success" ? "succeeded"
+            : res === "escalate" ? "provoked hostility"
+                : "failed";
+        return `${iName}'s ${label.toLowerCase()} against ${tName} ${resultPhrase}.`;
+    }
+    // verbose
+    const detail = verboseDetail(action, outcome);
+    return `${iName} attempted ${label.toLowerCase()} on ${tName} — ${detail}.`;
+}

package/dist/src/dist.d.ts

@@ -0,0 +1,20 @@
+import { Q } from "./units.js";
+export interface RngLike {
+    q01(): Q;
+}
+export declare function tri01(rng: RngLike): Q;
+export declare function triSym(rng: RngLike): Q;
+export declare function mulFromVariation(variationSym: Q, amplitude: Q): Q;
+/**
+ * Symmetric triangular sample shifted by `bias × 0.5` of half-range, then
+ * clamped back to the natural triSym bounds `[−SCALE.Q/2, SCALE.Q/2]`.
+ *
+ * `bias` ∈ [−1, 1]:
+ *   +1 strongly skews toward high-end attribute values
+ *   −1 strongly skews toward low-end attribute values
+ *    0 is identical to an unbiased `triSym(rng)` call
+ *
+ * Used by `generateIndividual` to implement `NarrativeBias`.
+ */
+export declare function biasedTriSym(rng: RngLike, bias: number): Q;
+export declare function skewUp(mult: Q, steps: number): Q;