@maka/maka-cli 5.171.0 → 5.173.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.171.0",
+  "version": "5.173.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",

package/bundle/typescript/src/commands/game/sideQuest/commands/backlog.js

@@ -160,7 +160,14 @@ export class BacklogCommand extends Command {
             // different timestamps on different machines -- so without this
             // two reports about the same moment cannot be tied together. Seen
             // for real: one run produced items stamped 00-18-43 and 00-18-15.
-            sharedRunId: game?.remoteSession?.id,
+            // A HOSTED RUN NAMES ITSELF (2026-09-12, the reporter's note on
+            // ZdhkP8mAP9QhpqFvA): the browser client's session has no log
+            // file to upload, but its id is the key to the event stream the
+            // site keeps -- and the site reads the transcript off that
+            // (game-backlog-vetting.ts sessionEventsExcerpt). The CLI's own
+            // shared-run link keeps its id; the headless host's is the same
+            // GameSessions id under another name.
+            sharedRunId: game?.remoteSession?.id ?? currentSession()?.sessionId,
             cliVersion: cliVersion(),
             engineVersion: engineVersion(),
             platform: process.platform,

package/bundle/typescript/src/commands/game/sideQuest/commands/move.js

@@ -920,7 +920,12 @@ export class MoveCommand extends Command {
         actor.atSpot = spotForCell(room, cell);
         // A shell of yours on that square steps aside (spots.ts heelsTo).
         yieldSquareToMaster(room, actor);
-        actor.performAction('steps', `${taken} ${taken === 1 ? 'pace' : 'paces'} ${direction}`);
+        // A HUMAN'S PACES ARE QUIET TO THE OTHER HUMANS (uq3nyr2so2ch6E7Wj):
+        // the room's NPCs still see the step (their reactions ride the same
+        // event); the humans sharing the room watch the dot move instead of
+        // reading a line per pace. An NPC's steps stay narrated -- a guard
+        // closing the distance is worth a line.
+        actor.performAction('steps', `${taken} ${taken === 1 ? 'pace' : 'paces'} ${direction}`, { quiet: this.scene.isHumanControlled(actor) });
         this.trailCompanions();
         this.scene.updateStatus();
         this.scene.updateExits(room);

package/bundle/typescript/src/commands/game/sideQuest/commands/rest.js

@@ -7,13 +7,15 @@ import { ownedDrones } from '../utilities/owned-drones.js';
  * see use.ts): catch your breath somewhere safe. "Safe" means a
  * Residence-type room (your Hideout qualifies) or a room with no one else
  * in it -- nobody naps in front of an audience in the sprawl. Each rest
- * rolls Body and recovers hits + 1 stun; repeat as needed. Rest never
- * touches the physical track (bullet holes take medkits or a heal spell),
- * and you can't rest mid-combat-exchange.
+ * rolls Body and recovers hits + 1 stun; repeat as needed. A night in a
+ * bed that's yours is also the day of NATURAL RECOVERY for the physical
+ * track (SR5 p.207, built 2026-09-12 for vFMhSGwLhsfpiY7bs): Body x 2,
+ * each hit a box, only once the stun is gone. You can't rest
+ * mid-combat-exchange.
  */
 export class RestCommand extends Command {
     static verb = 'rest';
-    static description = 'Catch your breath somewhere safe to recover Stun (spell drain, stim crashes). Physical wounds need a medkit or a heal spell.';
+    static description = 'Catch your breath somewhere safe to recover Stun (spell drain, stim crashes). A night in your own bed also knits physical wounds (Body x 2, once the stun is gone) -- a medkit, a clinic ("treat") or a heal spell is the faster road.';
     async execute(_args = []) {
         const actor = this.actor;
         const room = actor.currentLocation;
@@ -35,7 +37,7 @@ export class RestCommand extends Command {
             .filter(i => i.droneDamage > 0);
         const othersHere = this.scene.getActorsInRoom(room).filter(a => a !== actor);
         const isResidence = room.roomType?.toLowerCase() === 'residence';
-        if (actor.stunTaken === 0 && damagedDecks.length === 0 && damagedDrones.length === 0) {
+        if (actor.stunTaken === 0 && actor.damageTaken === 0 && damagedDecks.length === 0 && damagedDrones.length === 0) {
             // Nothing to heal -- but sleeping is its own point now (needs
             // system: edge refills only fed-and-slept, see Game.
             // applyDepartureNeeds). A bed you own still counts slept-in even
@@ -101,6 +103,52 @@ export class RestCommand extends Command {
             lines.push(`  Rest: ${formatRoll(roll)}${tierDice > 0 ? ` (+${tierDice} -- a real bed)` : tierDice < 0 ? ` (${tierDice} -- the Street sleeps badly)` : ''}${healerDice ? ` (+${healerDice} -- quick healer)` : ''}${insomnia ? ' (halved -- sleep never comes easy)' : ''}${inDebtAtHome ? ' (halved -- shivering is not sleeping)' : ''}`);
             lines.push(`  ${recovered} stun recovered: ${actor.stunSummary()}`);
         }
+        // NATURAL RECOVERY, PHYSICAL (vFMhSGwLhsfpiY7bs, 2026-09-12: "when I
+        // rest, my physical health track doesn't heal"). Until now rest said
+        // bullet holes were medkit-or-spell business, and canon disagrees:
+        // p.207 heals Physical by rest -- Body x 2 (1 day) Extended Test,
+        // each hit a box -- once the Stun track is clear, since "Physical
+        // damage cannot be healed through rest if the character also has
+        // Stun damage". The engine's night in your own bed is that day (a
+        // job-site corner is not: it clears the head and nothing else);
+        // the stun roll above runs first, so a rest that empties the stun
+        // track goes on to knit bone the same night. Modifiers ride as they
+        // do for stun: the bed's lifestyle dice, Quick Healer, and the
+        // doc's Medicine aftercare (+1 per hit, p.208). Glitches per p.207:
+        // a glitch only costs time this engine has no clock for; a critical
+        // glitch adds 1D3 boxes -- fresh damage, a fresh set of wounds.
+        if (actor.damageTaken > 0 && !actor.isDown()) {
+            if (actor.stunTaken > 0) {
+                lines.push(`  The wounds wait: a body clears the stun before it knits bone.${hint(' (Rest again once your head is clear.)')}`);
+            }
+            else if (!isResidence) {
+                lines.push(`  Bone knits on a full day's rest in a bed that's yours -- a corner of a job site only clears the head.`);
+            }
+            else {
+                const tierDice = this.game?.lifestyle?.restDice ?? 0;
+                const healerDice = actor.bonus('healing');
+                const careDice = actor.medicineCareDice;
+                const roll = rollPool(Math.max(1, actor.body * 2 + tierDice + healerDice + careDice));
+                const knit = roll.criticalGlitch ? 0 : roll.hits;
+                const healed = knit > 0 ? actor.healDamage(knit) : 0;
+                let worse = 0;
+                if (roll.criticalGlitch)
+                    worse = actor.takeDamage(1 + Math.floor(Math.random() * 3));
+                this.logger.write(`RestCommand: ${actor.name} recovery (Body x2) knit ${healed} physical (${actor.damageTaken}/${actor.maxConditionBoxes})${careDice ? ` [aftercare +${careDice}d]` : ''}${roll.criticalGlitch ? ` [critical glitch: +${worse}]` : ''}.`);
+                lines.push(`  Recovery: ${formatRoll(roll)} (Body x 2${tierDice > 0 ? `, +${tierDice} the bed` : tierDice < 0 ? `, ${tierDice} the Street` : ''}${healerDice ? `, +${healerDice} quick healer` : ''}${careDice ? `, +${careDice} the doc's aftercare` : ''})`);
+                if (roll.criticalGlitch) {
+                    lines.push(`  Something tears in the night -- ${worse} box${worse === 1 ? '' : 'es'} worse: ${actor.conditionSummary()}`);
+                }
+                else if (healed > 0) {
+                    lines.push(`  ${healed} box${healed === 1 ? '' : 'es'} knit: ${actor.conditionSummary()}`);
+                }
+                else {
+                    lines.push(`  Nothing knits tonight -- the body takes its time.`);
+                }
+                if (actor.damageTaken === 0)
+                    actor.clearMedicineCare();
+            }
+        }
         for (const deck of damagedDecks) {
             const wasBricked = deck.isBricked;
             // Juryrigger (p.75): +2 on the bench -- coaxing boards back to life
@@ -124,7 +172,7 @@ export class RestCommand extends Command {
             lines.push(`  Airframe work on the ${drone.name}: ${formatRoll(repairRoll)}`);
             lines.push(`  ${repaired} box${repaired === 1 ? '' : 'es'} trued and patched: ${drone.droneSummary()}${wasWrecked && !drone.isWrecked ? ' -- the rotors answer again.' : ''}`);
         }
-        lines.push(actor.stunTaken === 0 && !damagedDecks.some(d => d.deckDamage > 0) && !damagedDrones.some(d => d.droneDamage > 0)
+        lines.push(actor.stunTaken === 0 && actor.damageTaken === 0 && !damagedDecks.some(d => d.deckDamage > 0) && !damagedDrones.some(d => d.droneDamage > 0)
             ? `  Head clear, gear humming. Back to work.`
             : hint(`  (Rest again to keep recovering.)`));
         this.actor.performAction('rests', '');

package/bundle/typescript/src/commands/game/sideQuest/commands/treat.js

@@ -1,5 +1,6 @@
 import { Command } from './command.js';
 import { sameSpot, spotOf, spotRefusal } from '../utilities/spots.js';
+import { TREAT_PRICE_PER_BOX, applyMedicineCare, isClinicRoom, isStreetDoc } from '../utilities/street-doc.js';
 /**
  * Street-doc services (SR5e p.42, "Staying Healthy"): paid physical
  * healing at a clinic -- the certain, expensive alternative to burning
@@ -10,7 +11,7 @@ import { sameSpot, spotOf, spotRefusal } from '../utilities/spots.js';
 export class TreatCommand extends Command {
     static verb = 'treat';
     static description = 'Pay a street doc to close your physical wounds -- 100 nuyen per box, no dice, no risk. Works at a clinic with the doc present.';
-    static PRICE_PER_BOX = 100;
+    static PRICE_PER_BOX = TREAT_PRICE_PER_BOX;
     async execute(_args = []) {
         const actor = this.actor;
         if (actor.plane !== 'meat') {
@@ -23,12 +24,13 @@ export class TreatCommand extends Command {
             return `You're past treatment.`;
         }
         const room = actor.currentLocation;
-        const isClinic = room.roomType === 'Clinic' || /clinic|infirmary|surgery/.test(`${room.roomType ?? ''} ${room.name}`.toLowerCase());
-        if (!isClinic) {
+        // The clinic and the doc are decided in utilities/street-doc.ts --
+        // the same predicates that tell the doc's AI brief what it sells.
+        if (!isClinicRoom(room)) {
             return `Treatment happens at a clinic -- there's one on Market Row.`;
         }
         const doc = this.scene.getActorsInRoom(room)
-            .find((a) => a !== actor && a.plane === 'meat' && !a.isIncapacitated() && a.skillRating('first-aid') >= 4);
+            .find((a) => a !== actor && isStreetDoc(a));
         if (!doc) {
             return `The clinic's open but nobody with steady hands is in it.`;
         }
@@ -64,6 +66,13 @@ export class TreatCommand extends Command {
         ];
         if (actor.damageTaken > 0) {
             lines.push(`  "${actor.damageTaken} more when you can afford it. Try not to reopen my work."`);
+            // MEDICINE'S AFTERCARE (p.207-208; XpW98XthhN4biT4gM): the doc's
+            // one Medicine + Logic test on this set of wounds rides the boxes
+            // the patient could not pay for as bonus dice on their recovery
+            // rests. Once per set; free with any treatment.
+            const care = applyMedicineCare(doc, actor);
+            if (care)
+                lines.push(care);
         }
         // Bleeding on someone's table is how you get to know them.
         const bond = this.game?.touchContact(doc.name, 'trade', cost);

package/bundle/typescript/src/commands/game/sideQuest/engine-version.js

@@ -396,5 +396,24 @@
 //   room's live grid, every body's engine-resolved square, and the room
 //   panel's own hostile test; the map event carries the fog-applied
 //   district layout (data.district). Envelope and beat shape both grew.
-export const ENGINE_VERSION = '1.45.0';
+// 1.46.0 (2026-09-12): EVERY HUMAN AT THE TABLE HAS A SHEET. The condition
+//   sink is handed the reporting actor's name, and every human at a hosted
+//   table reports (late joiners included), not just the primary. The beat's
+//   actors carry kind 'party' for the table's other humans and
+//   `phaseActor` (a name, or null) for whose Action Phase is live in the
+//   room; the encounter beats every human in its room when the phase
+//   changes hands. Another human's plain paces are no longer narrated to
+//   the room's other humans.
+// 1.47.0 (2026-09-12): THE BODY HEALS. Rest at home runs canon's natural
+//   recovery for the Physical track (Body x 2, each hit a box, once the
+//   stun is gone; critical glitch worsens). The clinic's treatment throws
+//   in Medicine aftercare (+hits as recovery dice, once per set of wounds,
+//   persisted), the street doc has the Medicine skill, and a doc asked
+//   about wounds names the verb and the price.
+// 1.48.0 (2026-09-12): THE ROOM AND THE REPORT. A hosted run's backlog
+//   report names its session (sharedRunId) so the site can vet it with the
+//   run's own transcript; an exit-serving spot that is furniture (a booth,
+//   a counter) sits beside its doorway instead of on it; a job's objective
+//   is clamped to a carriable weight at scene build.
+export const ENGINE_VERSION = '1.48.0';
 //# sourceMappingURL=engine-version.js.map

package/bundle/typescript/src/commands/game/sideQuest/factories/scene-factory.js

@@ -5,6 +5,9 @@ import { Door } from '../models/door.js';
 import { RoomFactory } from './room-factory.js';
 import { NPCFactory } from './npc-factory.js';
 import { ItemFactory } from './item-factory.js';
+/** The heaviest a job's prize may be: a Strength 1 runner carries 30 kg
+ *  (player.ts maxCarryingWeight), and they still need room for gear. */
+export const OBJECTIVE_MAX_WEIGHT_KG = 15;
 import { Category } from '../types/shared/item-enum.js';
 import { Logger } from '../utilities/logger.js';
 import { migrateLegacySeed } from './seed-migration.js';
@@ -262,6 +265,21 @@ Key Locations: ${json.rooms.map(r => r.name).join(', ')}
         const itemMap = new Map();
         for (const itemJson of json.items ?? []) {
             const item = await itemFactory.createItemFromJson(itemJson);
+            // THE PRIZE HAS TO BE CARRIABLE (KSfzQzuHTx7kHjohi, 2026-09-12:
+            // "I shouldn't have an item I need to return, that I can't carry
+            // -- this case is too heavy"). The seed's items are written by a
+            // model that does not know the carry cap (20 + Strength x 10 kg,
+            // player.ts maxCarryingWeight); a "heavy case" at 60 kg is a job
+            // no runner can finish. The win condition's item is clamped to a
+            // weight the weakest runner can lift -- an objective you cannot
+            // pick up is a seed error, not a challenge. Other items keep
+            // whatever the seed said.
+            if (json.winCondition?.item === item.name) {
+                if (item.weight > OBJECTIVE_MAX_WEIGHT_KG) {
+                    console.warn(`[scene] objective "${item.name}" weighs ${item.weight} kg -- clamped to ${OBJECTIVE_MAX_WEIGHT_KG} so it can be carried.`);
+                    item.weight = OBJECTIVE_MAX_WEIGHT_KG;
+                }
+            }
             itemMap.set(item.name, item);
             // Step 4.5: Distribute Items
             if (itemJson.heldBy) {

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

@@ -2393,33 +2393,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // nowhere else, so NPCs and crew shells (which are Players too)
         // never report; the anonymous/bench gate is evaluated at fire time
         // because _anonymous is decided after construction.
-        this.player.onConditionChanged = () => {
-            // THE TERMINAL'S ROOM PANE RIDES THE SAME SIGNAL (q6tBaFn5EDmGMoJFh):
-            // the room now reports every occupant's move to the humans in it
-            // (Room.noteOccupancyChanged), and this is the one hook a human's
-            // report fires -- so a body stepping across the room while the
-            // player watches repaints here at once, not on the next keystroke
-            // or the 2-second map heartbeat. Same call a typed move makes;
-            // updateExits is a no-op without a screen, and combat repaints
-            // itself blow by blow (see mapHeartbeatTick).
-            if (this._mapBox && !this.player.inExchange)
-                this.updateExits(this.player.currentLocation);
-            if (this._anonymous || this._bench)
-                return;
-            // Checked HERE too, before the import -- a dynamic import after a
-            // Jest file's teardown is itself the failure, so the gate cannot
-            // live only on the far side of one. Irrelevant when a conditionSink
-            // is wired (no DDP hop for that path to silence).
-            if (!this._conditionSink && process.env.MAKA_NO_DDP === '1')
-                return;
-            void import('./utilities/condition-report.js')
-                .then(m => m.reportConditionSoon(this.player, this._conditionSink, {
-                // The room panel's own red (updateExits below): stance OR live
-                // enmity in the viewer's encounter. Same predicate, same map.
-                isHostile: a => hostileByStance(a) || enemyInFight(this.scene, this.player, a),
-            }))
-                .catch(() => undefined);
-        };
+        this.wireConditionReporting(this.player);
         // A ROOM CHANGE IS A SAVE BEAT (player request 2026-09-02): where you
         // stand in the hub is what a resume restores, so it has to reach the
         // save -- and the server -- as you walk, not only at quit. requestSave
@@ -2450,6 +2424,61 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             });
         }).catch(() => undefined);
     }
+    /**
+     * THE LIVE-SHEET HOOK, PER HUMAN (2026-09-12, genfBamjTvyHTdWhu: "in a
+     * shared run, I'm not the leader. I have no room map"). This used to be
+     * set inline in the constructor for the primary alone, so on a hosted
+     * table only the leader's overlay ever moved -- every other human's
+     * web Room box waited on a beat that never came. Same hook, now
+     * installable on any human at the table: the constructor calls it for
+     * the primary; headless.ts's addPlayer calls it for a late joiner.
+     *
+     * A NON-PRIMARY REPORTS ONLY THROUGH AN IN-PROCESS SINK. The HubLink
+     * path reports as the LOGGED-IN ACCOUNT's own runner (the server keys
+     * the overlay off this.userId), so a second human's beat sent that way
+     * would land on somebody else's sheet. Without a sink -- the solo CLI,
+     * a harness -- a late joiner simply gets no hook, which is what they
+     * always had. NPCs and crew shells (Players too) never come through
+     * here, so they never report.
+     */
+    wireConditionReporting(player) {
+        const primary = player === this.player;
+        if (!primary && !this._conditionSink)
+            return;
+        player.onConditionChanged = () => {
+            // THE TERMINAL'S ROOM PANE RIDES THE SAME SIGNAL (q6tBaFn5EDmGMoJFh):
+            // the room now reports every occupant's move to the humans in it
+            // (Room.noteOccupancyChanged), and this is the one hook a human's
+            // report fires -- so a body stepping across the room while the
+            // player watches repaints here at once, not on the next keystroke
+            // or the 2-second map heartbeat. Same call a typed move makes;
+            // updateExits is a no-op without a screen, and combat repaints
+            // itself blow by blow (see mapHeartbeatTick).
+            if (primary && this._mapBox && !this.player.inExchange)
+                this.updateExits(this.player.currentLocation);
+            if (this._anonymous || this._bench)
+                return;
+            // Checked HERE too, before the import -- a dynamic import after a
+            // Jest file's teardown is itself the failure, so the gate cannot
+            // live only on the far side of one. Irrelevant when a conditionSink
+            // is wired (no DDP hop for that path to silence).
+            if (!this._conditionSink && process.env.MAKA_NO_DDP === '1')
+                return;
+            void import('./utilities/condition-report.js')
+                .then(m => m.reportConditionSoon(player, this._conditionSink, {
+                // The room panel's own red (updateExits below): stance OR live
+                // enmity in the viewer's encounter. Same predicate, same map.
+                isHostile: a => hostileByStance(a) || enemyInFight(this.scene, player, a),
+                // The table's other humans (tngyd7sRda2omZQGF) -- the same
+                // "is this a human" the scene answers everywhere else.
+                isParty: a => a !== player && this.scene.isHumanControlled(a),
+                // Whose Action Phase is live in the viewer's room
+                // (PYK6zCKhQcjRFwLSQ); undefined between phases and out of a fight.
+                phaseActor: () => this.scene.encounterIn(player.currentLocation)?.phaseActor?.name,
+            }))
+                .catch(() => undefined);
+        };
+    }
     registerCommands() {
         CommandFactory.registerCommand('look', LookCommand);
         CommandFactory.registerCommand('go', GoCommand);

package/bundle/typescript/src/commands/game/sideQuest/headless.js

@@ -400,6 +400,18 @@ export async function createHeadlessSession(opts) {
                 // NPC stepping on its own reflect chain between commands
                 // reaches the browser without anyone typing.
                 game.player.noteConditionChanged();
+                // EVERY OTHER HUMAN WHO SAW THE ROOM CHANGE (genfBamjTvyHTdWhu):
+                // a member's overlay is written from the member's OWN beat now
+                // (Game.wireConditionReporting), so the same once-per-command
+                // nudge covers the typist and whoever shares their room -- a
+                // kill or a loot changes the room for all of them.
+                const typist = game.scene.getPlayerByName(actorName);
+                for (const p of game.scene.getPlayers()) {
+                    if (p === game.player || game.scene.deadPlayers.has(p.name))
+                        continue;
+                    if (p === typist || (typist && p.currentLocation === typist.currentLocation))
+                        p.noteConditionChanged();
+                }
                 return res;
             })),
             addPlayer: (save) => runInSession(ctx, async () => {
@@ -424,9 +436,20 @@ export async function createHeadlessSession(opts) {
                     logger.write(`addPlayer: ${existing.name} is already seated -- treating as a RECONNECT, not a join.`);
                     logger.status(existing.name, game.statusLinesFor(existing));
                     pushMap();
+                    // The browser's Room box reads the overlay, not the room
+                    // event: one fresh beat so a reconnecting member repaints
+                    // their own map too (genfBamjTvyHTdWhu).
+                    existing.noteConditionChanged();
                     return existing.name;
                 }
                 const p = buildPlayerFromSave(save);
+                // A MEMBER'S OWN LIVE-SHEET LANE (genfBamjTvyHTdWhu: "in a
+                // shared run, I'm not the leader. I have no room map"). The
+                // hook the constructor installs on the primary, installed on
+                // the joiner too: their beats reach the sink under their own
+                // name and the host writes them to THEIR overlay. Wired before
+                // the spawn so the seating below is the first beat.
+                game.wireConditionReporting(p);
                 const room = spawnRoom();
                 game.scene.addPlayer(p, room);
                 // ROOM GRIDS (spatial wave 2026-08-25, included shared-run
@@ -438,6 +461,7 @@ export async function createHeadlessSession(opts) {
                 if (spot)
                     p.atSpot = spot;
                 loadContract(save);
+                p.noteConditionChanged();
                 logger.system(`${p.name} steps out of a taxi and into the job.`, 'all', 'joined', { player: p.name });
                 logger.status(p.name, game.statusLinesFor(p));
                 pushMap();

package/bundle/typescript/src/commands/game/sideQuest/models/npc.js

@@ -1,4 +1,6 @@
 import { registerNotice, registerProvocation, PROVOCATION } from '../utilities/hostile-contact.js';
+import { hint } from '../utilities/hints.js';
+import { WOUND_TALK, isClinicRoom, isStreetDoc, streetDocBrief, treatHint } from '../utilities/street-doc.js';
 import { capitalCase } from 'change-case';
 import { tableCrewNote, tableDeliveryNote } from '../utilities/table-notes.js';
 import { Player } from './player.js';
@@ -1611,6 +1613,18 @@ ${worldEventsSummary}
             return;
         }
         this.logger.write('Attempting to respond');
+        // THE DOC NAMES THE VERB (XpW98XthhN4biT4gM, 2026-09-12: "I just
+        // asked the doc for help with my wounds ... not just 'do nothing'").
+        // Whatever the model makes of it, a bleeding patient asking a street
+        // doc about wounds gets the one line that actually helps, under the
+        // reply: the command and the price. Deterministic, so it does not
+        // depend on the AI reading its own brief (streetDocBrief below).
+        if (isStreetDoc(this) && isClinicRoom(this.currentLocation) && WOUND_TALK.test(message)
+            && (actor.damageTaken > 0 || actor.stunTaken > 0)) {
+            const h = hint(treatHint());
+            if (h)
+                this.logger.logWithColor(h, 'white', { actor: actor.name });
+        }
         // A fresh stimulus earns at most one fresh speech (see the field doc)
         // -- and a clean slate of attempts. Something new has happened, so
         // what didn't work against the OLD situation is worth trying again.
@@ -1665,6 +1679,9 @@ ${worldEventsSummary}
         // circling closer"). Same shape as payoutSummary above -- nothing
         // told the model the run's actual heat, so a reassuring line had
         // nothing to check itself against.
+        // What this NPC SELLS, told to the model (XpW98XthhN4biT4gM): the
+        // street doc's trade is treatment, and the word for it is "treat".
+        const servicesSummary = isStreetDoc(this) && isClinicRoom(this.currentLocation) ? streetDocBrief() : '';
         const heat = this._scene?.ownerGame?.heatSummaryForDialogue?.();
         const heatSummary = heat
             ? `The district's current HEAT on this run is ${heat}. If you would naturally reassure them that things are quiet, clean, or under control, that claim has to be TRUE against this -- never tell them the coast is clear, that nobody noticed, or that things went quiet if heat says otherwise. Speak honestly about how hot it actually is instead.`
@@ -2124,6 +2141,7 @@ Your objective is to drive the story line.`}
     ${dialogueSummary}
     ${eph ? '' : payoutSummary}
     ${eph ? '' : heatSummary}
+    ${eph ? '' : servicesSummary}
     ${eph ? '' : jobItemSummary}
 
     ${roomDesc}${spotBlock}${combatSpatialBlock}

package/bundle/typescript/src/commands/game/sideQuest/models/player.js

@@ -2827,19 +2827,29 @@ export class Player extends AbstractPlayer {
         }
         this.logger.logWithColor(`{white-fg}${actor.name}:{/white-fg} ${message}`, (actor === this) ? 'yellow' : 'green', { actor: this.name });
     }
-    see(actor, verb, details) {
+    see(actor, verb, details, quiet) {
         if (actor !== this && this.canPerceive(actor)) {
             this.logger.write(`You see ${actor.name} ${verb} ${details}`);
+            // A QUIET ACT IS SEEN, NOT NARRATED (2026-09-12, uq3nyr2so2ch6E7Wj:
+            // "let's not show the individual steps the other players are
+            // making"). Your own plain step already says nothing (move.ts,
+            // QUIET STEPS: the map shows where you stand); another human's
+            // step printed "<name> steps 2 paces north" to everyone sharing
+            // the room, every pace, and the map was already moving their dot.
+            // The event still fans out -- an NPC's see() reacts to it the same
+            // as before -- only the human's log line is dropped.
+            if (quiet)
+                return;
             this.logger.logWithColor(`${actor.name} ${verb} ${details}`, 'cyan');
         }
     }
-    performAction(verb, details) {
+    performAction(verb, details, opts) {
         const message = `${this.name} performs '${verb}'${details ? `: ${details}` : ''}`;
         this.logger.write(message);
-        this.emit('action', { actor: this, verb, details });
+        this.emit('action', { actor: this, verb, details, quiet: opts?.quiet === true });
     }
-    _onSeenAction = ({ actor, verb, details }) => {
-        void this.see(actor, verb, details);
+    _onSeenAction = ({ actor, verb, details, quiet }) => {
+        void this.see(actor, verb, details, quiet);
     };
     // FOG OF WAR (map ruling 2026-08-24): the map only shows where you've
     // been. Room names, stamped at the one choke point every movement path
@@ -2929,6 +2939,20 @@ export class Player extends AbstractPlayer {
      * healed" (p.205). Set by cast.ts's heal, cleared with the above.
      */
     magicallyHealed = false;
+    /**
+     * MEDICINE'S AFTERCARE (SR5 p.207-208; 2026-09-12, XpW98XthhN4biT4gM):
+     * a Medicine + Logic test tended to these wounds, once per set, and its
+     * hits ride every natural-recovery rest as bonus dice until the wounds
+     * close. Cleared with the set. Persisted (persistence.ts) -- the doc
+     * is in the hub and so is the bed, but a save can sit between them.
+     */
+    medicineCareGiven = false;
+    medicineCareDice = 0;
+    /** The wounds closed: nothing left for the aftercare to help. */
+    clearMedicineCare() {
+        this.medicineCareGiven = false;
+        this.medicineCareDice = 0;
+    }
     /** Applies damage boxes; returns the number actually taken. */
     /**
      * THE LIVE-SHEET HOOK (2026-09-01): Game sets this on the PRIMARY
@@ -2960,6 +2984,7 @@ export class Player extends AbstractPlayer {
     clearWoundSet() {
         this.firstAidGiven = false;
         this.magicallyHealed = false;
+        this.clearMedicineCare();
     }
     /**
      * Clears damage boxes; returns how many were actually healed (can be

package/bundle/typescript/src/commands/game/sideQuest/scenes/scene2.json

@@ -624,6 +624,7 @@
           "charisma": 3,
           "skills": {
             "first-aid": 6,
+            "medicine": 6,
             "perception": 4,
             "negotiation": 3
           }

package/bundle/typescript/src/commands/game/sideQuest/utilities/combat-turn.js

@@ -389,9 +389,26 @@ export class CombatEncounter {
             this.running = false;
         }
     }
+    /**
+     * WHOSE PHASE, ON EVERY HUMAN'S MAP (2026-09-12, PYK6zCKhQcjRFwLSQ: "on
+     * the map, who's turn it is I'd like a stroke around the icon that
+     * pulses"). The condition beat carries the room's live phase holder
+     * (condition-report.ts phaseActor); a beat only fires off a Player's
+     * own hook, and a phase changing hands mutates nobody's monitors -- so
+     * the encounter tells every human in its room, the way the room does
+     * for a move (Room.noteOccupancyChanged). Coalesced downstream: a
+     * phase that opens and closes in one tick is one beat per watcher.
+     */
+    notePhaseChanged() {
+        for (const a of this.room.getActors()) {
+            if (this.scene.isHumanControlled(a))
+                a.noteConditionChanged();
+        }
+    }
     async beginPhase(p) {
         this.phaseActor = p.actor;
         this.budget = new ActionBudget();
+        this.notePhaseChanged();
         p.surprised = false;
         p.delayed = false;
         p.nudges = 0;
@@ -452,6 +469,7 @@ export class CombatEncounter {
         p.delayed = true;
         this.phaseActor = undefined;
         this.budget = undefined;
+        this.notePhaseChanged();
         if (others.length === 0) {
             // Nobody left to wait for -- the delayed phase is simply now.
             p.delayed = false;
@@ -469,6 +487,7 @@ export class CombatEncounter {
         p.delayed = false;
         this.phaseActor = undefined;
         this.budget = undefined;
+        this.notePhaseChanged();
         this.scene.notifyExchangeSettled(this.participants.map(x => x.actor));
     }
     /** The phase actor has left the room or fallen: the pass moves on. */
@@ -594,6 +613,7 @@ export class CombatEncounter {
         this.ended = true;
         this.phaseActor = undefined;
         this.budget = undefined;
+        this.notePhaseChanged();
         for (const p of this.participants) {
             p.actor.clearAim();
             p.actor.recoilRoundsFired = 0;

package/bundle/typescript/src/commands/game/sideQuest/utilities/condition-report.js

@@ -99,7 +99,7 @@ function roomGridFor(player) {
     }
 }
 export function buildConditionReport(player, deps) {
-    const { saveSlug, arSightUp, isHostile } = deps;
+    const { saveSlug, arSightUp, isHostile, isParty, phaseActor } = deps;
     // BRICKED INCLUDED (web report 2026-09-02: "my deck got bricked, but its
     // status still says 4/12"): a forced dump clears activeDeck and
     // getCyberdeck() hides a bricked deck, so the beat read nothing and the
@@ -250,9 +250,12 @@ export function buildConditionReport(player, deps) {
             // THE SAME RED THE ROOM PANEL USES (see IConditionReportDeps
             // .isHostile): stance flag OR live enmity, and never a
             // surrendered one -- hostileByStance owns that clause.
+            // PARTY BEFORE EVERYTHING BUT DOWN (tngyd7sRda2omZQGF): another
+            // human at the table is your party whatever else is true of them.
             kind: a.isIncapacitated() ? 'downed'
-                : a.allyOf ? 'ally'
-                    : (isHostile?.(a) ?? hostileByStance(a)) ? 'hostile' : 'neutral',
+                : isParty?.(a) ? 'party'
+                    : a.allyOf ? 'ally'
+                        : (isHostile?.(a) ?? hostileByStance(a)) ? 'hostile' : 'neutral',
             role: actorRole(a),
             spot: a.atSpot,
             cell: a.atCell ?? seats.get(a.name),
@@ -261,6 +264,13 @@ export function buildConditionReport(player, deps) {
         // panel's 💀. Gone from the list the moment a body is picked clean
         // (loot.ts removeBody), which with the per-command beat is at once.
         bodies: roomBodies(player),
+        // WHOSE PHASE (PYK6zCKhQcjRFwLSQ): a name while an Action Phase is
+        // live in the viewer's room, `null` when none is -- an explicit
+        // nobody, because the site $sets only what a beat carries, and an
+        // absent field would leave the last phase holder pulsing after the
+        // fight was over. Not on the beat at all when the caller has no
+        // Scene to ask (harness, bench).
+        ...(phaseActor ? { phaseActor: phaseActor() ?? null } : {}),
     };
 }
 function roomBodies(player) {
@@ -297,7 +307,7 @@ function noteRoster(report) {
 const ADDITIVE_FIELDS = [
     'ar', 'actors', 'deckLine', 'deckDamage', 'astralPerceiving', 'bodyRoom', 'sustainingPenalty',
     'matrix', 'panMarks', 'hostMarksOnYou', 'marksPlaced', 'marksOnYou', 'deckStored', 'droneDamage', 'companions', 'pools', 'initiative',
-    'karma', 'nuyen', 'edge', 'grid', 'bodies',
+    'karma', 'nuyen', 'edge', 'grid', 'bodies', 'phaseActor',
 ];
 /** Refusal reasons already written to the session log -- one line each. */
 const announcedRefusals = new Map();
@@ -342,13 +352,13 @@ extra) {
             // stance and brandish flow through their accessors' own reports;
             // sustained and deck programs are composed here and ride whatever
             // beat fires next. All read at FIRE time, like position.
-            const report = buildConditionReport(player, { saveSlug, arSightUp, isHostile: extra?.isHostile });
+            const report = buildConditionReport(player, { saveSlug, arSightUp, isHostile: extra?.isHostile, isParty: extra?.isParty, phaseActor: extra?.phaseActor });
             noteRoster(report);
             if (sink) {
                 // IN-PROCESS: no HubLink, no MAKA_NO_DDP gate, no version-skew
                 // retry -- the engine module and its caller are always the same
                 // deployed version here (see ConditionSink's doc comment).
-                await sink(report);
+                await sink(report, player.name);
                 return;
             }
             const { HubLink } = await import('./shared-run.js');

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

@@ -359,6 +359,8 @@ export function serializePlayer(p) {
         stunTaken: p.stunTaken,
         firstAidGiven: p.firstAidGiven,
         magicallyHealed: p.magicallyHealed,
+        medicineCareGiven: p.medicineCareGiven,
+        medicineCareDice: p.medicineCareDice,
         needs: {
             ateThisCycle: p.ateThisCycle, sleptThisCycle: p.sleptThisCycle,
             hungerStreak: p.hungerStreak, sleepStreak: p.sleepStreak,
@@ -522,6 +524,8 @@ export function restorePlayer(p, s) {
     // -- a reload would launder a spent medkit into a fresh one.
     p.firstAidGiven = s.firstAidGiven ?? false;
     p.magicallyHealed = s.magicallyHealed ?? false;
+    p.medicineCareGiven = s.medicineCareGiven ?? false;
+    p.medicineCareDice = s.medicineCareDice ?? 0;
     p.addLockedFatigue('hunger', s.needs.hungerFatigue);
     p.addLockedFatigue('sleep', s.needs.sleepFatigue);
     p.ateThisCycle = s.needs.ateThisCycle;

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

@@ -1,4 +1,11 @@
 import { Direction } from '../types/shared/direction-enum.js';
+export function doorwayKindOf(spotName) {
+    if (/stair|\bsteps?\b|ladder|hatch|shaft|chute|\bramp\b|\blift\b|elevator|escalator/i.test(spotName))
+        return 'vertical';
+    if (/door|entrance|entry|threshold|gate|arch|portal|airlock/i.test(spotName))
+        return 'lateral';
+    return undefined;
+}
 export const METERS_PER_CELL = 2;
 /**
  * How tall one storey is. A CHOICE, not a citation -- SR5 never says how
@@ -609,7 +616,23 @@ export function synthesizeGrid(input) {
     // own walls; the hub sits where all of them are plausibly reachable.
     for (const [spotName, served] of exitCellsBySpot.entries()) {
         if (served.length === 1) {
-            grid.spotCells.set(spotName, served[0]);
+            // FURNITURE BESIDE THE DOOR, NOT IN IT (XanDMPmRrbJQ8ta8e,
+            // 2026-09-12: "the corner booth is right in front of the door
+            // north ... doors and booths should not be on top of each
+            // other"). A seed may name any spot as the one an exit is
+            // reached from -- "the booth by the north door". Only a spot
+            // that IS a doorway (a door, a gate, the stairs) takes the
+            // doorway cell; a booth, a counter or a bar takes the nearest
+            // free cell beside it instead. The doorway and its approach are
+            // already claimed above, so "nearest free" is next to the door,
+            // never on it or in front of it.
+            if (doorwayKindOf(spotName)) {
+                grid.spotCells.set(spotName, served[0]);
+                continue;
+            }
+            const beside = nearestFree(served[0], occupied, dims, exists);
+            claim(beside);
+            grid.spotCells.set(spotName, beside);
             continue;
         }
         const mid = {

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

@@ -2,7 +2,10 @@ import { Direction } from '../types/shared/direction-enum.js';
 import { significantWords, wordsAreCloseEnough } from './fuzzy-match.js';
 import { hint } from './hints.js';
 import { placeName } from './log-style.js';
-import { findPath, distanceMeters, coverBetween, blockingRegionFor, pathClimbSteps, levelFootprint, key, isCellBlocked, pathSqueezes, METERS_PER_CELL, } from './room-grid.js';
+import { findPath, distanceMeters, coverBetween, blockingRegionFor, pathClimbSteps, levelFootprint, key, isCellBlocked, pathSqueezes, METERS_PER_CELL, doorwayKindOf, } from './room-grid.js';
+// The doorway vocabulary moved to room-grid.ts (the grid seats exit
+// spots by it); every caller of spots.ts keeps its import.
+export { doorwayKindOf };
 /**
  * Intra-room locations ("at" spots -- player request: every room felt
  * like everything stood at your elbow; walking into the bar had both
@@ -1283,13 +1286,31 @@ export function lockedRouteHint(room, direction, door) {
     }
     return '';
 }
-export function doorwayKindOf(spotName) {
-    if (/stair|\bsteps?\b|ladder|hatch|shaft|chute|\bramp\b|\blift\b|elevator|escalator/i.test(spotName))
-        return 'vertical';
-    if (/door|entrance|entry|threshold|gate|arch|portal|airlock/i.test(spotName))
-        return 'lateral';
-    return undefined;
-}
+/**
+ * WHAT KIND OF WAY THROUGH a spot's name describes, or undefined when
+ * it isn't a way through at all (a bar, a workbench, the stalls).
+ *
+ * THE ONE DOORWAY PREDICATE (item A, 2026-08-27). There were two
+ * separately-written copies of this regex -- here in entrySpotFor and
+ * in Room.namedDoorwayFor -- free to drift apart, and neither knew the
+ * distinction that actually matters: a "back door" is a LATERAL way
+ * through and a "way down" is a VERTICAL one. Kind-blindness is what
+ * let namedDoorwayFor bind a spot called "the back door" to a DOWN
+ * exit, which put the basement's barrier at the back door (the player's
+ * report) and, because vertical exits are centre-placed, simultaneously
+ * put the back door in the middle of the room (the older report). One
+ * defect, two bug reports.
+ *
+ * This is a PERMANENT component, not a migration shim. Generation is
+ * moving toward binding every exit to a spot explicitly, but that data
+ * is model-written: validation can make it right more often, never
+ * always. And every scene seeded before that lands has nothing but
+ * names, forever. So this is the honest floor under a seed that is
+ * silent or lying, and it is the LAST resort -- an explicit
+ * room.exitSpots binding always wins.
+ *
+ * (Definition now in room-grid.ts -- see the re-export at the top.)
+ */
 /** The kind of way through a given direction NEEDS. */
 export function exitDoorwayKind(direction) {
     return direction === Direction.UP || direction === Direction.DOWN ? 'vertical' : 'lateral';

package/bundle/typescript/src/commands/game/sideQuest/utilities/street-doc.js

@@ -0,0 +1,67 @@
+import { rollPool, formatRoll } from './dice.js';
+/**
+ * THE STREET DOC, IN ONE PLACE (2026-09-12; XpW98XthhN4biT4gM "I just
+ * asked the doc for help with my wounds -- I want them to help me with my
+ * wounds, for a cost of course... not just 'do nothing'", and
+ * 4Yz2PGLNoFAfdd2Wt's note: "The Doc in the hub should have a heal
+ * ability ... He should charge of course, and have a very high skill in
+ * all things medical").
+ *
+ * The clinic verb (`treat`) has existed since the venue ruling of
+ * 2026-08-24 -- what did not exist was any way for the DOC to point a
+ * bleeding player at it. `ask`/`say` went to the AI with no idea the
+ * NPC sold anything, so "help me with my wounds" got a diagnosis and no
+ * treatment. The predicate `treat` gates on, the words the doc is told,
+ * and the deterministic hint the player sees all live here so the three
+ * cannot drift.
+ *
+ * MEDICINE'S AFTERCARE (SR5 p.207-208): Medicine does not close boxes; a
+ * Medicine + Logic [Mental] test gives +1 die per hit to the patient's
+ * later Recovery tests, once per set of wounds, never in combat. The
+ * clinic throws it in with treatment -- see applyMedicineCare.
+ */
+/** 100 nuyen a box -- the book's medkit-supply price point (treat.ts). */
+export const TREAT_PRICE_PER_BOX = 100;
+export function isClinicRoom(room) {
+    if (!room)
+        return false;
+    return room.roomType === 'Clinic'
+        || /clinic|infirmary|surgery/.test(`${room.roomType ?? ''} ${room.name}`.toLowerCase());
+}
+/** Steady hands: the same bar `treat` has always used (First Aid 4+),
+ *  or a Medicine rating that says the same thing. A body, awake. */
+export function isStreetDoc(actor) {
+    return actor.plane === 'meat'
+        && !actor.isIncapacitated()
+        && (actor.skillRating('first-aid') >= 4 || actor.skillRating('medicine') >= 4);
+}
+/** What a patient says when they mean their wounds. */
+export const WOUND_TALK = /\b(wound|wounds|wounded|hurt|hurting|bleed|bleeding|heal|healing|patch|stitch|stitches|injur\w*|medic\w*|treat\w*|damage|shot|bullet|fix me)\b/i;
+/** The deterministic line under the doc's reply -- the verb, the price. */
+export function treatHint(price = TREAT_PRICE_PER_BOX) {
+    return `("treat" -- the doc closes physical wounds, ${price}¥ a box, cash up front. Aftercare rides free.)`;
+}
+/** The doc's standing orders in the AI brief: treatment is the trade,
+ *  and the word for it is "treat". */
+export function streetDocBrief(price = TREAT_PRICE_PER_BOX) {
+    return `You are this clinic's STREET DOC and treatment is your trade: you close physical wounds for ${price} nuyen a box, cash up front, no names asked. The player makes it happen by typing the command "treat" -- when anyone asks for help with wounds, tell them that word plainly and quote the price. Never say you cannot help a paying patient and never leave them with a diagnosis alone; if they are broke, name the price and mean it. Stun is not your department -- sleep is free.`;
+}
+/**
+ * Medicine + Logic, once per set of wounds (p.208): the hits ride on the
+ * patient as bonus dice for natural recovery (rest.ts) until the wounds
+ * close or fresh damage opens a new set. Returns the line to print, or
+ * undefined when there is nothing to apply (no Medicine on the doc, no
+ * wounds, or this set already tended).
+ */
+export function applyMedicineCare(doc, patient) {
+    if (patient.damageTaken === 0 || patient.medicineCareGiven)
+        return undefined;
+    const skill = doc.skillRating('medicine');
+    if (skill <= 0)
+        return undefined;
+    const roll = rollPool(skill + doc.logic);
+    patient.medicineCareGiven = true;
+    patient.medicineCareDice = roll.hits;
+    return `  Aftercare -- Medicine + Logic: ${formatRoll(roll)}. +${roll.hits} ${roll.hits === 1 ? 'die' : 'dice'} on your recovery rests until these wounds close.`;
+}
+//# sourceMappingURL=street-doc.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.171.0",
+  "version": "5.173.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",