@maka/maka-cli 5.197.0 → 5.199.0

package/bundle/typescript/src/commands/game/sideQuest/utilities/beat-echo.js

@@ -0,0 +1,160 @@
+/**
+ * THE SAME BEAT TWICE (aCErAfvEW7G23FWDM, reporter: "The NPC speaking
+ * the same thing, this is likely something more pervasive, and not
+ * really logically an issue of the scene").
+ *
+ * They were right that it is pervasive: THERE IS NO DEDUPE OF EMITTED
+ * TEXT ANYWHERE IN THIS ENGINE. Not a hash, not a similarity check, not
+ * a recently-said buffer. What exists is four things that all stop
+ * short of it:
+ *
+ *   - the prompt asks nicely ("Do NOT repeat, rephrase, or re-ask
+ *     anything you have already said"), and the session that filed this
+ *     item has an NPC delivering one hook twice in two phrasings;
+ *   - _spokeThisStimulus allows one speech per stimulus, which does
+ *     nothing about the NEXT stimulus a second later;
+ *   - _triedThisStimulus dedupes normalized COMMAND STRINGS, not prose;
+ *   - Room.crowdNote tells each NPC that others are answering too --
+ *     and its own test says the behavioural claim is "UNVERIFIABLE BY
+ *     CONSTRUCTION", because the fan-out is parallel and un-awaited.
+ *
+ * That last one is the reason this has to be a gate at EMISSION rather
+ * than another sentence in a prompt. Two NPCs answering the same
+ * stimulus are already in flight when either one's prompt is built;
+ * neither can be told what the other is about to say. Only the thing
+ * that prints them both can know.
+ *
+ * THE TWO REPORTED PAIRS, both from 2026-09-15T14-45-01-617Z:
+ *
+ *   11:05:10  "Tallow keeps wiping the glass, watching Ted's body stir
+ *              behind the beads, then glances at Kessler."
+ *             "Tallow keeps polishing the same glass, eyes flicking
+ *              toward the back room as the beads settle."
+ *
+ *   10:57:18  "Chapel on Tallow Street. The Drowned Choir -- sang for
+ *              the dead, then went quiet. I want the quiet explained."
+ *   10:57:19  "Chapel on Tallow Street. The Drowned Choir. Answer me
+ *              one question -- why did the singing stop?"
+ *
+ * Note what they are NOT: identical. A hash would catch neither. They
+ * are the same BEAT rewritten, which is what a model does when it is
+ * asked twice in two seconds with the same context, and it is why the
+ * test below is written against these exact lines.
+ */
+/** How long a line stays echo-able. Beyond this an NPC returning to
+ *  their glass is a character trait, not a stutter. */
+export const ECHO_WINDOW_MS = 45_000;
+/** How many lines per room to remember. Small deliberately: this is a
+ *  stutter detector, not a transcript. */
+const ECHO_DEPTH = 12;
+/** Words that carry no identity, so overlap on them means nothing.
+ *  Deliberately broader than utilities/fuzzy-match.ts's STOPWORDS,
+ *  which is tuned for matching NAMES rather than prose. */
+const NOISE = new Set([
+    'a', 'an', 'the', 'and', 'or', 'but', 'of', 'on', 'in', 'at', 'to', 'for',
+    'with', 'from', 'by', 'as', 'is', 'are', 'was', 'were', 'be', 'been',
+    'it', 'its', 'he', 'she', 'they', 'them', 'his', 'her', 'their', 'him',
+    'that', 'this', 'these', 'those', 'then', 'than', 'there', 'here',
+    'you', 'your', 'i', 'me', 'my', 'we', 'us', 'not', 'no', 'so', 'up',
+    'out', 'off', 'over', 'into', 'through', 'about', 'like', 'just',
+]);
+/**
+ * Keyed on the ROOM OBJECT, weakly. A room that leaves play takes its
+ * echoes with it, and nothing here keeps a scene alive.
+ */
+const heard = new WeakMap();
+function contentWords(line) {
+    return line
+        .toLowerCase()
+        .replace(/[^\w\s']/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 1 && !NOISE.has(w));
+}
+/**
+ * CONTAINMENT, not Jaccard, and the difference decides whether this
+ * works. Jaccard divides by the UNION, so a long line and a short one
+ * saying the same thing score low purely because one has more words --
+ * and "Tallow keeps polishing the same glass" scores 0.2 against its
+ * own twin. Containment asks the question actually being asked: how
+ * much of the SHORTER line is already in the longer one.
+ */
+function containment(a, b) {
+    if (a.length === 0 || b.length === 0)
+        return 0;
+    const set = new Set(b);
+    let shared = 0;
+    const seen = new Set();
+    for (const w of a) {
+        if (seen.has(w))
+            continue;
+        seen.add(w);
+        if (set.has(w))
+            shared += 1;
+    }
+    return shared / Math.min(new Set(a).size, new Set(b).size);
+}
+/**
+ * SAME SPEAKER, SAME OPENING. "Tallow keeps wiping" and "Tallow keeps
+ * polishing" share their first two content words, and that is a
+ * stronger signal of a stutter than any amount of shared vocabulary
+ * later in the sentence -- it is the shape of a model restarting the
+ * same thought. Paired with a low overlap bar it catches the Tallow
+ * pair, which pure overlap (0.36) would otherwise let through.
+ */
+function sameOpening(a, b) {
+    if (a.length < 2 || b.length < 2)
+        return false;
+    return a[0] === b[0] && a[1] === b[1];
+}
+/** Overlap at which two lines by one speaker are the same beat. */
+const SAME_SPEAKER = 0.5;
+/** ...and the lower bar once they also START the same way. */
+const SAME_SPEAKER_OPENING = 0.3;
+/**
+ * Two DIFFERENT NPCs delivering one hook. A higher bar on purpose:
+ * people in a room legitimately talk about the same thing, and two
+ * characters agreeing is a scene rather than a bug. Only near-identical
+ * content is a second delivery of the same line.
+ */
+const OTHER_SPEAKER = 0.65;
+/**
+ * HAS THIS ROOM JUST HEARD THIS?
+ *
+ * Records the line when it is new, so callers need exactly one call.
+ * A line judged an echo is NOT recorded -- it never reached anybody, so
+ * it cannot be the thing a third line echoes.
+ *
+ * @param room    the room object the line prints in
+ * @param speaker who is saying it
+ * @param line    the emitted prose, as the player would read it
+ * @param now     injectable clock; the window is the only time rule
+ */
+export function judgeEcho(room, speaker, line, now = Date.now()) {
+    if (!room)
+        return { echo: false };
+    const words = contentWords(line);
+    // Too short to judge. "Drek." twice in a row is a person, not a
+    // stutter, and there is not enough here to tell them apart.
+    if (words.length < 4)
+        return { echo: false };
+    const log = (heard.get(room) ?? []).filter(e => now - e.at < ECHO_WINDOW_MS);
+    for (const prior of log) {
+        const overlap = containment(words, prior.words);
+        const mine = prior.speaker === speaker;
+        const bar = mine
+            ? (sameOpening(words, prior.lead) ? SAME_SPEAKER_OPENING : SAME_SPEAKER)
+            : OTHER_SPEAKER;
+        if (overlap >= bar) {
+            heard.set(room, log);
+            return { echo: true, of: prior.speaker };
+        }
+    }
+    log.push({ speaker, words, lead: words, at: now });
+    heard.set(room, log.slice(-ECHO_DEPTH));
+    return { echo: false };
+}
+/** Test seam: forget what a room has heard. */
+export function forgetEchoes(room) {
+    heard.delete(room);
+}
+//# sourceMappingURL=beat-echo.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/catalog.js

@@ -927,6 +927,31 @@ export function metamagicFor(key) {
         ...baseFields(row),
     })).get(key);
 }
+/**
+ * A FACTION ROW, rebuilt as the engine reads it (aCErAfvEW7G23FWDM).
+ *
+ * Same shape as every other kind: the rows live on maka-cli.com and the
+ * engine ships none. An unknown slug answers undefined and every rule
+ * in factions.ts treats that as "no opinion" -- a cached catalog from
+ * before v20 simply behaves the way the engine did before factions.
+ */
+export function factionFor(key) {
+    return kindIndex('faction', row => ({
+        key: row.slug,
+        name: row.name,
+        description: row.description,
+        sort: row.faction.sort,
+        ...(row.faction.parent !== undefined ? { parent: row.faction.parent } : {}),
+        ...(row.faction.standing !== undefined ? { standing: row.faction.standing } : {}),
+        ...(row.faction.territorial !== undefined ? { territorial: row.faction.territorial } : {}),
+        ...(row.faction.discreet !== undefined ? { discreet: row.faction.discreet } : {}),
+        page: row.page ?? '',
+    })).get(key);
+}
+/** Every faction the resolved catalog knows. */
+export function catalogFactions() {
+    return listOfKind('faction', factionFor);
+}
 /** Every metamagic and echo the resolved catalog knows. */
 export function catalogMetamagics() {
     return listOfKind('metamagic', metamagicFor);

package/bundle/typescript/src/commands/game/sideQuest/utilities/earshot.js

@@ -1,4 +1,4 @@
-import { sameSpot, spotOf, spotsActive, OPEN_FLOOR } from './spots.js';
+import { sameSpot, spotOf, spotsActive, OPEN_FLOOR, IMMEDIATE_VICINITY_M, actorDistanceMeters } from './spots.js';
 /**
  * WHO CAN OVERHEAR A MURMUR (playtest, Deditri: "a private place for
  * calls"). A call is audible to the room, and that is correct and
@@ -17,17 +17,25 @@ import { sameSpot, spotOf, spotsActive, OPEN_FLOOR } from './spots.js';
  * Market's "shadowed edge". Nothing new is invented here; the call path
  * just respects the position everyone else already respects.
  *
- * THE RULE, and why it is not Room.say's rule: room speech that finds
- * nobody at your spot escalates to a SHOUT and carries room-wide -- that
- * is how you call across a bar. A commlink held to your face never
- * escalates; talking quietly into it is the whole point of it. So a
- * murmur reaches your spot and stops there.
+ * THE RULE, and why it is STILL not Room.say's rule. A murmur into a
+ * commlink reaches your spot and stops there, full stop -- talking
+ * quietly into a phone is the whole point of a phone, and it never
+ * escalates however alone you are standing.
  *
- * WHAT DOES NOT BUY PRIVACY, deliberately:
+ * Room speech used to share that shape and no longer does. `say` is now
+ * bounded by each LISTENER's hearing range in real metres
+ * (canHearSpeech below, en3p6eCpiRuqsTSKm) and never escalates on its
+ * own; shouting is a verb you type (commands/shout.ts). The two rules
+ * live in one file so they can be read against each other, which is the
+ * lesson of the drift that produced this module in the first place.
+ *
+ * WHAT DOES NOT BUY PRIVACY ON A CALL, deliberately:
  *  - CIRCULATING (no atSpot) is the compat state and means "anywhere in
- *    the room" -- it both reaches and is reached by everything. It is
- *    also the common case, and it stays exactly as loud as it has always
- *    been.
+ *    the room" -- your half of a CALL still reaches and is reached by
+ *    everything, because there is no spot for it to stop at. Note this
+ *    is the opposite of what circulating now means for ordinary speech,
+ *    and the asymmetry is argued at canHearSpeech: a murmur has a place
+ *    it comes from and a phone call does not.
  *  - THE OPEN FLOOR is a real position but it is bare ground in the
  *    middle of the room, no cover, always visible (see spots.ts). Being
  *    apart from people is not the same as being out of earshot, and a
@@ -40,6 +48,141 @@ import { sameSpot, spotOf, spotsActive, OPEN_FLOOR } from './spots.js';
  * Nothing here caches, stores, or derives a second notion of where
  * anybody is.
  */
+/**
+ * HOW FAR ORDINARY SPEECH CARRIES, and how far one listener can hear it
+ * (en3p6eCpiRuqsTSKm: "'say' should only be perceived by anyone within
+ * 3-5m un-augmented. Really, it's the audible perception range of the
+ * listener").
+ *
+ * CANON IS SILENT ON THE DISTANCE, checked rather than assumed. SR5
+ * handles hearing as dice and limits, never as a range table: an audio
+ * enhancement "adds its Rating to your limit in audio Perception Tests"
+ * (p.445), cyberears give "hearing with normal ranges" (p.453-454), and
+ * the only metre figures anywhere near it belong to the directional and
+ * laser microphones (p.445, 100 m). There is no rule for how far a
+ * sentence travels, so THESE NUMBERS ARE THIS ENGINE'S, said out loud
+ * rather than dressed as the book's.
+ *
+ * What is defensible about them:
+ *  - 5 m is already this engine's word for conversational range
+ *    (spots.ts IMMEDIATE_VICINITY_M, and voiceBandFor calls anything
+ *    inside it 'conversation'). Speech reaching exactly as far as the
+ *    engine already says a conversation reaches is one number, not two.
+ *  - The listener's perception dice extend it. Canon gives audio gear a
+ *    DICE/LIMIT bonus and this engine models speech by DISTANCE, so the
+ *    conversion is ours; a metre per die is the smallest unit that can
+ *    express "you hear better than they do" in a model made of 2 m
+ *    cells. Cyberears (+1) hear a metre further. That is an
+ *    extrapolation of a canon bonus, not a canon rule.
+ */
+export const SPEECH_METERS = IMMEDIATE_VICINITY_M;
+/**
+ * A SHOUT (commands/shout.ts) -- "anyone within a reasonable distance,
+ * 50m?" Also this engine's number and not the book's. In practice it is
+ * room-wide: the largest room this generator builds is tens of metres
+ * across, so the figure is a ceiling that says "the whole place hears
+ * you" rather than a boundary anyone will stand outside.
+ */
+export const SHOUT_METERS = 50;
+/**
+ * How far THIS listener can hear, in metres. The report's own framing:
+ * range is a property of the ear, not of the mouth.
+ *
+ * Reads the same `perception` pool a Perception test reads, so a piece
+ * of chrome and a quality that both say "+1 perception" extend hearing
+ * identically and neither needs a line here. Never below the base -- a
+ * perception PENALTY should make you miss things you roll for, not
+ * shrink the room to nothing.
+ */
+export function hearingRangeMeters(listener) {
+    // AN EAR IS NOT AN EYE (aCErAfvEW7G23FWDM: "a human officer standing
+    // 20 meters away... shouldn't overhear w/o augmentation").
+    //
+    // This used to read augBonus('perception'), which is ONE FLAT LANE
+    // OVER EVERY SENSE -- so cybereyes (+2) and vision-enhancement-3 (+3)
+    // extended how far their owner could HEAR. Nobody noticed because a
+    // perception POOL genuinely does not care which sense noticed; it
+    // only became wrong when this function made that pool a distance.
+    // Audio chrome now declares `hearing` (augmentations.ts AugBonusKind,
+    // and the same lane on the site's catalog rows).
+    //
+    // QUALITIES STAY ON `perception` and that is not an oversight: the
+    // quality this fans in is Perceptive, which is a whole-sense trait
+    // ("you notice things"), not a piece of ear. A quality that meant
+    // hearing specifically would declare `hearing` like any row.
+    const bonus = listener.augBonus('hearing') + listener.qualityBonus('perception');
+    return Math.max(SPEECH_METERS, SPEECH_METERS + bonus);
+}
+/**
+ * CAN THIS LISTENER HEAR ORDINARY SPEECH FROM THERE -- the whole of the
+ * `say` rule, in one place so the verb, the NPC fan-out and any future
+ * reader cannot drift apart the way Room.say and murmurAudience once did.
+ *
+ * THE CIRCULATING ASYMMETRY, which is the actual defect this item was
+ * filed about. "Circulating" (no atSpot) is the compat state meaning
+ * "somewhere in this room, unfixed", and the old rule read it as "at
+ * every spot at once" -- so a circulating listener heard everything.
+ * That is how a patrol officer walking through the back room answered a
+ * question put to a Johnson at a table (CugfYsH8DWH8FcfgS, same
+ * session): Kessler was `moving through`, so he was nowhere, so he was
+ * everywhere.
+ *
+ * ASK spotOf, NEVER actorCell. A circulating body IS given a cell by
+ * seatingIn -- its "drift seat" -- and that cell is deliberately not a
+ * position: spots.ts says so in as many words ("a place to DRAW
+ * someone, never a position they hold"), and sameSpot and canReach both
+ * short-circuit on atSpot before any of it is consulted. A distance
+ * check written against the drift seat would have put Kessler a
+ * plausible two metres from the table and let him hear after all --
+ * correct-looking arithmetic over a number that means nothing.
+ *
+ * A LISTENER with no position is therefore NOT in earshot of a murmur:
+ * someone crossing the room is not standing at your table. A SPEAKER
+ * with no position still reaches the room, and that is deliberate rather
+ * than an oversight -- they are moving among everybody, there is no
+ * "here" for the words to fall short of, and refusing to let a
+ * circulating player be heard at all would make the game's main verb
+ * fail for the commonest position in it.
+ *
+ * A room that declares NO spots keeps the old room-wide behaviour
+ * outright. There is no geometry in such a room to be near or far in,
+ * and inventing one would refuse speech in the small abstract rooms
+ * where `say` is all there is.
+ */
+/**
+ * CAN THIS LISTENER HEAR A SHOUT FROM THERE (aCErAfvEW7G23FWDM).
+ *
+ * SHOUT_METERS was declared, documented, and never read: Room.shout
+ * reached the whole room and measured the distance only to DESCRIBE the
+ * shout (voiceTag), never to bound it. Written here beside canHearSpeech
+ * for the reason this module exists at all -- two rules answering "who
+ * hears this" in two files is how Room.say and murmurAudience drifted
+ * apart in the first place.
+ *
+ * The listener's own range extends a shout exactly as it extends a
+ * murmur: the ear is the rule, the mouth only sets the baseline.
+ */
+export function canHearShout(speaker, listener) {
+    const room = speaker.currentLocation;
+    if (!spotsActive(room))
+        return true;
+    if (spotOf(speaker) === undefined || spotOf(listener) === undefined)
+        return true;
+    const reach = SHOUT_METERS + (hearingRangeMeters(listener) - SPEECH_METERS);
+    return actorDistanceMeters(room, speaker, listener) <= reach;
+}
+export function canHearSpeech(speaker, listener) {
+    const room = speaker.currentLocation;
+    if (!spotsActive(room))
+        return true;
+    // The speaker is unplaced: they are moving among everyone.
+    if (spotOf(speaker) === undefined)
+        return true;
+    // The listener is unplaced: they are passing through, not standing here.
+    if (spotOf(listener) === undefined)
+        return false;
+    return actorDistanceMeters(room, speaker, listener) <= hearingRangeMeters(listener);
+}
 /**
  * Everyone in the speaker's room close enough to catch a murmur.
  * From a named spot: whoever shares it, plus anyone circulating.

package/bundle/typescript/src/commands/game/sideQuest/utilities/grid-reach.js

@@ -213,6 +213,6 @@ export function hostDockLine(room, actor, width) {
                 : '';
     const raw = `${inside ? '▣' : '●'} ${room.name} HR${room.hostRating}${tag}`;
     const cut = [...raw].slice(0, Math.max(4, width)).join('');
-    return `{lightblue-fg}${cut}{/lightblue-fg}`;
+    return `{light-blue-fg}${cut}{/light-blue-fg}`;
 }
 //# sourceMappingURL=grid-reach.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/grid-view.js

@@ -460,20 +460,20 @@ export function gridSculpt(actor, room) {
         const purpose = room.host?.purpose;
         const sculpt = room.host?.sculpt;
         return [
-            `{lightblue-fg}INSIDE :: ${hostLabel(room, { capital: true }).toUpperCase()} [HR ${room.hostRating}]${purpose ? ` -- ${purpose}` : ''}{/lightblue-fg}`,
-            `{lightblue-fg}${sculpt ?? 'Architecture all the way around -- the outside grid is a wall away and might as well be weather.'}{/lightblue-fg}`,
+            `{light-blue-fg}INSIDE :: ${hostLabel(room, { capital: true }).toUpperCase()} [HR ${room.hostRating}]${purpose ? ` -- ${purpose}` : ''}{/light-blue-fg}`,
+            `{light-blue-fg}${sculpt ?? 'Architecture all the way around -- the outside grid is a wall away and might as well be weather.'}{/light-blue-fg}`,
         ].join('\n');
     }
     // ON THE GRID (SR5 pp.217-218): no street under the persona -- a black
     // flatland, the body's room named only because that is where the
     // signal comes from. A host directly overhead gets a line of its own.
     const body = actor.bodyRoom ?? room;
-    const header = `{lightblue-fg}THE GRID :: jacked in from ${body.name.toUpperCase()}{/lightblue-fg}`;
+    const header = `{light-blue-fg}THE GRID :: jacked in from ${body.name.toUpperCase()}{/light-blue-fg}`;
     const grid = actor.currentGrid;
-    const flat = `{lightblue-fg}Black flatland under a black sky -- the icons are the only things out here.${grid ? ` Riding ${grid.name}${grid.userPenalty ? ' (-2 on everything you do, p.233)' : ''}.` : ''}{/lightblue-fg}`;
+    const flat = `{light-blue-fg}Black flatland under a black sky -- the icons are the only things out here.${grid ? ` Riding ${grid.name}${grid.userPenalty ? ' (-2 on everything you do, p.233)' : ''}.` : ''}{/light-blue-fg}`;
     if (!room.hasNode)
         return `${header}\n${flat}`;
-    return `${header}\n${flat}\n{lightblue-fg}${hostLabel(room, { capital: true })} hangs directly overhead, sealed. What it holds is inside it.{/lightblue-fg}`;
+    return `${header}\n${flat}\n{light-blue-fg}${hostLabel(room, { capital: true })} hangs directly overhead, sealed. What it holds is inside it.{/light-blue-fg}`;
 }
 /**
  * The icons rendered as the standard cyan block, or the thin-grid line.
@@ -502,19 +502,19 @@ export function gridIconBlock(scene, actor, room, rooms) {
     if (actor.insideHost || !rooms) {
         const icons = gridIcons(scene, actor, room);
         if (icons.length === 0) {
-            return `{lightblue-fg}Thin grid out here -- background noise, nothing worth cracking.{/lightblue-fg}`;
+            return `{light-blue-fg}Thin grid out here -- background noise, nothing worth cracking.{/light-blue-fg}`;
         }
-        return `{lightblue-fg}ICONS IN REACH:{/lightblue-fg}\n${icons.map(i => `  {lightblue-fg}${i}{/lightblue-fg}`).join('\n')}`;
+        return `{light-blue-fg}ICONS IN REACH:{/light-blue-fg}\n${icons.map(i => `  {light-blue-fg}${i}{/light-blue-fg}`).join('\n')}`;
     }
     const out = [];
     const hosts = hostsInReach(rooms, actor);
     out.push(hosts.length > 0
-        ? `{lightblue-fg}HOSTS OVERHEAD:{/lightblue-fg}\n${hosts.map(h => `  {lightblue-fg}${hostLine(h, actor)}{/lightblue-fg}`).join('\n')}`
-        : `{lightblue-fg}Nothing overhead -- no host stands over this district.{/lightblue-fg}`);
+        ? `{light-blue-fg}HOSTS OVERHEAD:{/light-blue-fg}\n${hosts.map(h => `  {light-blue-fg}${hostLine(h, actor)}{/light-blue-fg}`).join('\n')}`
+        : `{light-blue-fg}Nothing overhead -- no host stands over this district.{/light-blue-fg}`);
     const near = gridIcons(scene, actor, gridVicinity(actor)).filter(i => !isHostLine(i));
     out.push(near.length > 0
-        ? `{lightblue-fg}ICONS IN REACH:{/lightblue-fg}\n${near.map(i => `  {lightblue-fg}${i}{/lightblue-fg}`).join('\n')}`
-        : `{lightblue-fg}Nothing near -- background noise around your signal.{/lightblue-fg}`);
+        ? `{light-blue-fg}ICONS IN REACH:{/light-blue-fg}\n${near.map(i => `  {light-blue-fg}${i}{/light-blue-fg}`).join('\n')}`
+        : `{light-blue-fg}Nothing near -- background noise around your signal.{/light-blue-fg}`);
     // FARTHER OUT, WITHOUT AN ADDRESS (SR5 p.235, p.243): Matrix Perception
     // never tells you where a device physically sits -- that is Trace Icon,
     // two marks and an opposed test. So far icons are listed by the noise
@@ -539,9 +539,9 @@ export function gridIconBlock(scene, actor, room, rooms) {
         byBand.set(noise, list);
     }
     const far = [...byBand.entries()].sort((a, b) => a[0] - b[0])
-        .map(([noise, names]) => `  {lightblue-fg}· dim, noise -${noise}: ${names.join(', ')}{/lightblue-fg}`);
+        .map(([noise, names]) => `  {light-blue-fg}· dim, noise -${noise}: ${names.join(', ')}{/light-blue-fg}`);
     if (far.length > 0)
-        out.push(`{lightblue-fg}FARTHER OUT -- dimmer with distance:{/lightblue-fg}\n${far.join('\n')}`);
+        out.push(`{light-blue-fg}FARTHER OUT -- dimmer with distance:{/light-blue-fg}\n${far.join('\n')}`);
     // A blank line between the distance bands (user, 2026-09-02): three
     // sections read as three when they do not touch.
     return out.join('\n\n');
@@ -556,7 +556,7 @@ export function gridIconBlock(scene, actor, room, rooms) {
  * the other personas, and the files. Cut to the dock's rows and columns.
  */
 export function hostInteriorPanel(scene, actor, host, rows, cols) {
-    const cut = (raw) => `{lightblue-fg}${[...raw].slice(0, Math.max(4, cols)).join('')}{/lightblue-fg}`;
+    const cut = (raw) => `{light-blue-fg}${[...raw].slice(0, Math.max(4, cols)).join('')}{/light-blue-fg}`;
     const lines = [];
     lines.push(cut(`INSIDE ${host.name}`));
     if (host.purpose)

package/bundle/typescript/src/commands/game/sideQuest/utilities/hostile-contact.js

@@ -8,8 +8,16 @@ import { Logger } from './logger.js';
  * and nothing happened" cannot recur.
  */
 export const PATIENCE_BEATS = 3;
-/** What a hostile watching you do it will not let pass (performAction verbs). */
-export const PROVOCATION = /^(draws\b|casts\b|chants a summoning)/;
+/**
+ * What a hostile watching you do it will not let pass (performAction verbs).
+ *
+ * `grapples` joined on 2026-09-15 (aCErAfvEW7G23FWDM). Seizing someone
+ * is a melee attack in canon (p.195) and reads as one to anybody in the
+ * room, but the ladder did not list it -- so a hostile could stand and
+ * watch you lay hands on their colleague and count it as patience. The
+ * verb is the one grapple.ts passes to performAction.
+ */
+export const PROVOCATION = /^(draws\b|casts\b|chants a summoning|grapples\b)/;
 /** The hostiles in `room` who could open on `player` -- structural, no LLM. */
 export function hostilesIn(scene, room, player) {
     const out = [];
@@ -43,6 +51,44 @@ export function standDown(npc) {
     npc.hostile = false;
     npc.hostileContact = undefined;
 }
+/**
+ * THE MIRROR OF standDown, and until 2026-09-15 it did not exist
+ * (aCErAfvEW7G23FWDM).
+ *
+ * `hostile` was written at BOOT and nowhere else -- scene-factory from
+ * the seed, street-gang at ganger spawn, ic-actors for a program. The
+ * only runtime writer in the whole engine was standDown, which can
+ * only ever turn hostility OFF. So an NPC who was not hostile when the
+ * scene was built had no path to becoming hostile, whatever you did to
+ * them: the bartender you grabbed by the collar could be provoked in
+ * prose and never in fact.
+ *
+ * ONE WRITER, here, for the same reason hostile-contact.ts has always
+ * insisted on one opener (see the header): hostility that can be set
+ * from anywhere is hostility nobody can explain afterwards. Callers
+ * pass WHY, and it is logged.
+ *
+ * This does NOT open a fight by itself. It puts the NPC on the ladder
+ * -- noticed, and provoked as of this beat -- and the ordinary
+ * hostileContactBeat decides when they act on it. An act that should
+ * start a fight NOW opens the encounter itself (grapple.ts, attack.ts).
+ */
+export function turnHostile(npc, beat, why) {
+    if (npc.hostile === true) {
+        // Already opposition: the act still counts as provocation, which is
+        // what moves a patient hostile off the fence.
+        registerProvocation(npc, beat);
+        return;
+    }
+    // A COMPANION IS NEVER TURNED. A bound spirit or a hired drone
+    // answers to its master (models/npc.ts allyOf); flipping one hostile
+    // from a passing act would hand the player's own crew to the scene.
+    if (npc.allyOf)
+        return;
+    npc.hostile = true;
+    npc.hostileContact = { noticedBeat: beat, provokedBeat: beat };
+    Logger.getInstance().write(`${npc.name} turns hostile: ${why}.`);
+}
 function onPhysicalPlane(player) {
     return player.plane === 'meat' || player.plane === 'drone';
 }

package/bundle/typescript/src/commands/game/sideQuest/utilities/matrix-style.js

@@ -1,4 +1,4 @@
-export const MATRIX_COLOR = 'lightblue';
+export const MATRIX_COLOR = 'light-blue';
 export const FEED_COLOR = 'white';
 export const TURN_COLOR = 'yellow';
 /** Matrix-plane prose, tagged. */