@maka/maka-cli 5.198.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

@@ -95,7 +95,22 @@ export const SHOUT_METERS = 50;
  * shrink the room to nothing.
  */
 export function hearingRangeMeters(listener) {
-    const bonus = listener.augBonus('perception') + listener.qualityBonus('perception');
+    // 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);
 }
 /**
@@ -134,6 +149,28 @@ export function hearingRangeMeters(listener) {
  * 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))

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/narration-limits.js

@@ -0,0 +1,235 @@
+/**
+ * WHAT A BEAT MAY CLAIM (aCErAfvEW7G23FWDM).
+ *
+ * THE LINE THIS EXISTS FOR, from session 2026-09-15T14-45-01-617Z at
+ * 11:05:43, three seconds after the player typed "jack in":
+ *
+ *   "Ms. Quill plants a hand on Ted's shoulder, not gentle, steering
+ *    him toward the door before Kessler decides to make this paperwork."
+ *
+ * Nothing happened. No dice were rolled, no defence was offered, no
+ * Combat Turn opened, and Ted -- who was on the Ares grid with his body
+ * slumped in a bar -- had no way to answer any of it. The sentence was
+ * EXPOSITION: a non-command line of a model reply, printed to the
+ * player verbatim (models/npc.ts). The engine never saw an act at all,
+ * which is why no rule caught it.
+ *
+ * THE REPORTER'S OWN RULE, which is the one implemented here: "'plants
+ * hand on Ted's shoulder' is an emote, and that's fine, but moving
+ * someone against their will is a hostile action, and should start some
+ * sort of combat."
+ *
+ * So the boundary is not violence and it is not touch. It is AGENCY
+ * OVER SOMEBODY ELSE'S BODY. A beat may do anything it likes with the
+ * NPC's own body, mood, tone, props and surroundings -- that is the
+ * writing, and the writing is good. It may not move, hold, or lay hands
+ * on another actor, because those have mechanics (SR5 p.195 Subduing,
+ * resolved as an opposed Unarmed melee attack) and prose is not allowed
+ * to skip them.
+ *
+ * WHAT HAPPENS TO A CAUGHT LINE. It is suppressed and the NPC is told
+ * why, in the same breath, so the next beat can COMMIT to the act as a
+ * command instead of asserting it as a fact -- where the authorization
+ * gate, the dice and the Combat Turn all get their say. Refusing
+ * silently would just produce a mute NPC and a confused model.
+ *
+ * WHY A PREDICATE AND NOT A MODEL INSTRUCTION. The prompt has told the
+ * model to behave for a long time; it says "Do NOT repeat, rephrase, or
+ * re-ask" and the same session has an NPC delivering one hook twice in
+ * two phrasings. An instruction is advice. This is the engine.
+ *
+ * Exported and PURE for the same reason isOutOfCharacter is: it fails
+ * silently -- a pattern that stops matching does not throw, the line
+ * simply prints, and the only detector is a player watching their
+ * Johnson march them out of a bar they were not standing in.
+ */
+/**
+ * PUTTING HANDS ON SOMEBODY. Deliberately anchored on the ACT, not on
+ * the body part: "a hand on their shoulder" and "a hand on their arm"
+ * are the same claim, and enumerating anatomy is how a list like this
+ * rots.
+ *
+ * `grabs|seizes|...` carry their inflections because a beat is written
+ * in the present tense but a reflect line may not be.
+ */
+const CONTACT = new RegExp([
+    // "plants/lays/claps/puts/sets a hand on", and the bare "a hand on".
+    String.raw `\b(?:plant|lay|lays|clap|put|puts|set|sets|place|places|rest|rests|drop|drops)\w*\s+(?:a|her|his|their|one)\s+hands?\s+(?:on|against|to)\b`,
+    // "...hand closes around", whoever the hand belongs to. No determiner
+    // required: the fiction writes "Quill's hand closes around Ted's arm"
+    // as readily as "a hand closes", and both are the same claim.
+    String.raw `\bhands?\s+(?:lands?|closes?|clamps?|settles?|falls?|tightens?|locks?)\s+(?:on|around|over|about)\b`,
+    // Seizing and holding.
+    String.raw `\b(?:grab|grabs|grabbed|grabbing|seiz\w+|grip\w*|clutch\w*|clamp\w*|catch\w*|snatch\w*|takes?\s+hold|gets?\s+(?:a\s+)?(?:hand|grip|hold))\b`,
+    String.raw `\b(?:restrain\w*|pin\w*|wrestl\w*|manhandl\w*|hold\w*\s+(?:down|back|still))\b`,
+    // "holds Maka pinned", where the person sits BETWEEN the verb and the
+    // word that makes it a hold. The aimed-at test reads forward from a
+    // match, so the name has to be inside the match for this shape --
+    // found by sweeping the transcripts, where it is how a continuing
+    // grapple is always written.
+    String.raw `\bhold\w*\s+\w+(?:'s|’s)?\s*(?:pinned|down|still|fast|against|in place)\b`,
+    // Striking, shoving -- these ARE attacks and have their own verbs.
+    String.raw `\b(?:shov\w+|push\w*|punch\w*|slap\w*|strik\w+|kick\w*|slam\w*|throw\w*)\b`,
+    // "takes/catches them by the arm" -- the classic escort grip.
+    String.raw `\b(?:take|takes|took|catch|catches|caught|hook|hooks)\s+\w+(?:'s|’s)?\s*\w*\s+by\s+the\s+\w+`,
+].join('|'), 'i');
+/**
+ * MOVING SOMEBODY WHO DID NOT CHOOSE TO MOVE. The engine has no
+ * compelled-movement mechanic at all -- nothing anywhere writes another
+ * actor's position, and `follow` is opt-in with a leash that breaks the
+ * moment you are grappled. So this is not "use the other verb", it is
+ * "this cannot happen": the canon answer to wanting someone somewhere
+ * else is to hold them (p.195) and let them decide.
+ */
+const COMPELLED_MOVEMENT = new RegExp([
+    // INFLECTED FORMS ONLY for the ones whose stem is also a common NOUN.
+    // `bundl\w+` matched the item "Street Ammo Bundle" and turned a vendor
+    // receipt into an abduction; `herd` and `hustle` are nouns too. Same
+    // lesson as `tow` below, found the same way -- by sweeping the gate
+    // over every transcript on disk rather than by reading the pattern.
+    String.raw `\b(?:steer\w*|guid\w+|shepherd\w*|usher\w*|escort\w*|march\w*|propel\w*|herd(?:s|ed|ing)|bundl(?:es|ed|ing)|hustl(?:es|ed|ing)|hurr(?:y|ies|ied|ying))\b`,
+    // `tow` is spelled out rather than stemmed: `tow\w*` matches TOWARD,
+    // which appears in half the good lines in any transcript and quietly
+    // turned "slides a cred stick across the table toward Ted" into an
+    // abduction. A stem is only safe when no innocent word starts with it.
+    String.raw `\b(?:drag\w*|haul\w*|pull\w*|tug\w*|yank\w*|tows?|towed|towing|carr(?:y|ies|ied|ying)|lift\w*)\b`,
+    String.raw `\b(?:walk\w*|mov\w+|lead\w*|tak\w+)\s+\w+\s+(?:toward|towards|to|out|off|away|through|into|back)\b`,
+].join('|'), 'i');
+const ALLOWED = { refused: false };
+/**
+ * THE WORDS OF A NAME THAT CAN STAND FOR IT.
+ *
+ * "Ms. Quill" is abbreviated to "Quill" in every transcript, so a name
+ * has to match on its parts -- but ONLY the parts that identify
+ * somebody. A scene may legitimately hold an NPC called "The Drowned
+ * Choir" or a bar called "The Blind Eye", and letting "The" stand for
+ * either turns every "the cup" in the room into a person. Found by
+ * sweeping the gate over every transcript on disk: it was the last
+ * false positive left standing.
+ */
+const NOT_A_NAME = /^(?:the|and|of|an|mr|ms|mrs|dr|de|la|le|van|von)\.?$/i;
+function nameForms(name) {
+    const parts = name.split(/\s+/).filter(p => p.length > 2 && !NOT_A_NAME.test(p));
+    return [name, ...parts].map(p => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+}
+/**
+ * A possessive or object mention of somebody who is NOT the speaker.
+ *
+ * Names, not pronouns, and that is the whole reason this is tractable.
+ * A beat that says "steering him toward the door" with no name in it
+ * has no referent the engine can check, so it is left alone -- the
+ * reported line is caught because it says "Ted's shoulder" and
+ * "steering him" in ONE sentence, which is how these are actually
+ * written. Chasing pronouns across sentences would cost far more
+ * false positives than it would catch real ones.
+ */
+function subjectIn(line, others) {
+    for (const name of others) {
+        if (!name)
+            continue;
+        const forms = nameForms(name);
+        const re = new RegExp(`(?:^|[^\\w])(?:${forms.join('|')})(?:'s|’s)?(?:[^\\w]|$)`, 'i');
+        if (re.test(line))
+            return name;
+    }
+    return undefined;
+}
+/**
+ * DOES THE VERB LAND ON THIS PERSON?
+ *
+ * THE FALSE POSITIVES THIS EXISTS FOR, every one a verbatim line from a
+ * real session:
+ *   "Ms. Veil lifts the cup, watches Jynx over its rim."
+ *   "Jynx holds the camera out; Mr. Ibis snatches it up with both hands."
+ *   "Rhen pushes off the wall, inching toward the doorway where Vek stands."
+ *   "Brick's cyber-arms whir, the ledger clutched in his hands."
+ * Each has a contact verb AND somebody else's name, and each is good
+ * writing about an OBJECT or about the speaker's own body. A name
+ * somewhere in the sentence is not enough.
+ *
+ * Approximate and deliberately so: what follows a verb within a few
+ * words is its object far more often than not, and the alternative is
+ * a parser. Two shapes count as aimed at somebody:
+ *
+ *   1. the name (or an object pronoun) inside the next ~30 characters
+ *      -- "grabs Ted", "steers him toward the door", "holds Maka pinned";
+ *   2. the possessive-plus-body-part form the hand patterns produce --
+ *      "a hand on Ted's shoulder", where the name follows a preposition.
+ *
+ * "lifts the cup", "snatches it up" and "pushes off the wall" match
+ * neither, which is the entire point.
+ */
+function aimedAtAPerson(text, matches, subject) {
+    const target = new RegExp(`(?:${nameForms(subject).join('|')})|\\b(?:him|her|them|themselves)\\b`, 'i');
+    for (const m of matches) {
+        if (!m || m.index === undefined)
+            continue;
+        // THE MATCH ITSELF COUNTS, because some patterns swallow their own
+        // object: the compelled-movement rule is written as
+        // "walk|move|lead|take <something> toward", so in "walks Ted toward
+        // the door" the name is INSIDE the match and everything after it is
+        // furniture.
+        //
+        // SIXTEEN CHARACTERS, about three words, and the number is doing
+        // real work rather than being round. At thirty, "Ms. Veil lifts the
+        // cup, watches Jynx over its rim" reaches Jynx and a lovely line
+        // dies; at sixteen it does not, while "grabs Ted by the collar" and
+        // "steering him toward the door" both still land.
+        const end = m.index + m[0].length;
+        if (target.test(m[0] + text.slice(end, end + 16)))
+            return true;
+    }
+    return false;
+}
+/**
+ * MAY THIS BEAT SAY THIS?
+ *
+ * @param line     one exposition line of a model reply
+ * @param speaker  the NPC whose beat it is
+ * @param others   every other actor present, by name
+ * @param opts.holding  who this NPC already has a grapple on, if anyone --
+ *                 narration about a hold the dice already settled is a
+ *                 description, not a claim.
+ */
+export function judgeNarration(line, speaker, others, opts = {}) {
+    const t = line.replace(/^[\s│|>*-]+/, '').trim();
+    if (t.length === 0)
+        return ALLOWED;
+    const contactAt = t.match(CONTACT);
+    const movedAt = t.match(COMPELLED_MOVEMENT);
+    if (!contactAt && !movedAt)
+        return ALLOWED;
+    // WHO IS THE VERB AIMED AT -- asked of EVERY candidate rather than
+    // asked once of whoever is named first.
+    //
+    // Found by sweeping the transcripts: "Brick holds Maka pinned against
+    // the grate, his scarred face grim as he glances at Patches' slumped
+    // form" names two people. Resolving the subject first picked Patches
+    // (merely mentioned), then asked whether the verb was aimed at
+    // Patches, decided no, and let a real hold through. The question has
+    // to be asked per candidate or the answer depends on word order.
+    const subject = others
+        .filter(n => n && n !== speaker)
+        .find(n => subjectIn(t, [n]) && aimedAtAPerson(t, [contactAt, movedAt], n));
+    if (!subject)
+        return ALLOWED;
+    // ALREADY HOLDING THEM. If the engine says this NPC has a grapple on
+    // that target, then "Brick holds Maka pinned against the grate" is
+    // not a claim -- it is a DESCRIPTION of a state the dice already
+    // settled, and refusing it would gag the fiction about the one thing
+    // that IS mechanically true. Measured against every transcript on
+    // disk: without this, three of the nineteen refusals were an NPC
+    // narrating its own real grapple.
+    if (opts.holding && opts.holding === subject)
+        return ALLOWED;
+    // WHICH REFUSAL, because they are different rules with different
+    // answers. Contact has a verb and a rule behind it and the NPC should
+    // be told to use them. Compelled movement has NEITHER -- no mechanic
+    // exists for moving a body that did not choose to move -- so the note
+    // says the true thing rather than naming a verb that will not work.
+    const note = contactAt
+        ? `NARRATION CANNOT PUT HANDS ON ${subject.toUpperCase()}. Your last beat described doing it anyway, so it did not happen and the player was not shown it. Laying hold of someone is an Unarmed attack they get to defend against (Subduing, p.195) and it starts a fight. If you mean it, commit to it: "[COMMAND] grapple ${subject}". If you do not, describe your own body instead -- what your hands do short of touching them is yours to narrate.`
+        : `YOU CANNOT MOVE ${subject.toUpperCase()}. Your last beat described steering or carrying them somewhere, so it did not happen and the player was not shown it. Where a runner's body goes is theirs alone -- there is no way for you to walk them anywhere. Hold them where they stand if you must ("[COMMAND] grapple ${subject}", which starts a fight), ask them to come, or let them stay.`;
+    return { refused: true, subject, note };
+}
+//# sourceMappingURL=narration-limits.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/npc-authorization.js

@@ -0,0 +1,122 @@
+import { fuzzyPickName } from './fuzzy-match.js';
+const ALLOWED = { allowed: true };
+/**
+ * VERBS THAT PUT HANDS ON SOMEONE. The distinction that matters is not
+ * "is this violent" but "does this require the target's body to be
+ * there and able to answer for itself". Subduing (SR5 p.195) is the
+ * canonical one: it deals no damage at all and is still an Unarmed
+ * melee attack the target gets to defend against.
+ */
+const CONTACT_VERBS = new Set([
+    'attack', 'kill', 'subdue', 'grapple', 'restrain', 'clinch', 'struggle',
+    'palm', 'pick',
+]);
+/** Verbs whose first argument names another actor rather than an item
+ *  or a direction. Anything not listed here is authorized on the actor
+ *  alone -- we never guess a target out of an item name. */
+const ACTOR_TARGET_VERBS = new Set([
+    ...CONTACT_VERBS,
+    'cast', 'lead', 'order', 'give', 'talk-to', 'tell', 'treat', 'follow',
+]);
+/**
+ * The target named in the arguments, if this verb names one and the
+ * name resolves to somebody in the room. Deliberately the same fuzzy
+ * resolution the combat verbs use (utilities/fuzzy-match.ts), so a
+ * refusal and an execution disagree about who was meant exactly never.
+ *
+ * Returns undefined when no target is named OR when the name does not
+ * resolve -- an unresolvable name is the COMMAND's business to complain
+ * about ("You don't see X here"), not this module's. Refusing it here
+ * would replace a specific, useful refusal with a vague one.
+ */
+function namedTarget(scene, actor, verb, args) {
+    if (!ACTOR_TARGET_VERBS.has(verb))
+        return undefined;
+    const words = args.filter(w => !/^(the|a|an|at|to|with|from)$/i.test(w));
+    if (words.length === 0)
+        return undefined;
+    const room = actor.currentLocation;
+    if (!room)
+        return undefined;
+    // EVERY actor in the room, not the perceivable ones: this function
+    // answers "who did it mean", and the perception rule below is what
+    // answers "may it". Filtering by perception here would turn "you
+    // cannot see them" into a silent no-target and lose the reason.
+    const candidates = scene.getActorsInRoom(room).filter(a => a !== actor);
+    const picked = fuzzyPickName(words.join(' '), candidates.map(a => a.name));
+    return picked ? candidates.find(a => a.name === picked) : undefined;
+}
+/**
+ * MAY THIS AI-DRIVEN ACTOR RUN THIS COMMAND, RIGHT NOW.
+ *
+ * Called from CommandRegistry.parse for any command declaring
+ * npcPolicy 'authorized', and only for actors the scene does not
+ * consider human-controlled.
+ */
+export function authorizeNpcAction(scene, actor, verb, args) {
+    const target = namedTarget(scene, actor, verb, args);
+    if (!target)
+        return ALLOWED;
+    const contact = CONTACT_VERBS.has(verb);
+    // ORDER MATTERS HERE, and it is a writing decision as much as a rules
+    // one. A jacked-in runner fails BOTH tests below -- cross-plane
+    // perception and body presence -- and the perception rule would fire
+    // first if it were written first, refusing with "you cannot perceive
+    // them". That is true of the PERSONA and useless about the BODY,
+    // which is lying right there in the room and is what the act was
+    // reaching for. For a hands-on verb the absent-body reason is the one
+    // that tells the fiction something it can use.
+    if (contact && !isPresentInBody(target)) {
+        return {
+            allowed: false,
+            reason: `You can't lay hands on ${target.name}: they are not present in their body, and there is nobody home to resist you. Describe what you see, or wait for them to come back.`,
+        };
+    }
+    // YOU CANNOT ACT ON WHAT YOU CANNOT PERCEIVE. The engine's single
+    // cross-plane rule (Player.canPerceive) already gates hear() and
+    // see(), so an NPC never even WAKES for someone on another plane --
+    // but a beat woken by something else could still name them in a
+    // command, and did.
+    if (!actor.canPerceive(target)) {
+        return {
+            allowed: false,
+            reason: `You can't act on ${target.name} -- they are not something you can perceive from where you stand.`,
+        };
+    }
+    if (!contact)
+        return ALLOWED;
+    // LAYING HANDS ON SOMEONE WHO CANNOT ANSWER.
+    //
+    // This is the rung the reported session actually broke, and the
+    // reporter named the rule themselves: an emote is fine, "but moving
+    // someone against their will is a hostile action, and should start
+    // some sort of combat". Ms. Quill planted a hand on Ted's shoulder
+    // and steered him toward the door while Ted was JACKED IN -- a body
+    // slumped in a bar with nobody home to roll a defence.
+    //
+    // SR5 has no rule for this because SR5 assumes a person is present to
+    // defend: Subduing (p.195) is resolved as an opposed melee attack,
+    // and there is nothing to oppose. Rather than invent a defence pool
+    // for an empty body, the engine refuses the act. A runner's unattended
+    // body is not a prop the fiction may move.
+    if (target.isIncapacitated()) {
+        return {
+            allowed: false,
+            reason: `You can't -- ${target.name} is already down and cannot defend themselves.`,
+        };
+    }
+    return ALLOWED;
+}
+/**
+ * Is this actor home? A decker jacked into the Matrix, a magician
+ * projecting astrally and a rigger jumped into a drone all leave a body
+ * behind that is still listed in the room.
+ *
+ * `drone` is deliberately NOT here: a rigger jumped into an airframe is
+ * a physical machine in the meat world with its own defence, and
+ * grabbing one is an ordinary act of violence the engine can resolve.
+ */
+function isPresentInBody(actor) {
+    return actor.plane === 'meat' || actor.plane === 'drone';
+}
+//# sourceMappingURL=npc-authorization.js.map