@maka/maka-cli 5.199.0 → 5.201.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.199.0",
+  "version": "5.201.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/ask.js

@@ -7,6 +7,7 @@ import { FIXER_NAME, isFixerName } from '../factories/scene-seed-generator.js';
 import { sameSpot, spotOf, spotRefusal } from '../utilities/spots.js';
 import { catalogGear } from '../utilities/catalog.js';
 import { PAPER_AVAILABILITY } from '../utilities/sin.js';
+import { cleanupQuoteFor } from '../utilities/cleanup-hire.js';
 /**
  * Legwork (SR5e p.387-388): "ask <contact> about <thing>" taps a
  * CONTACT's network for real information -- in person or over a live
@@ -105,6 +106,15 @@ export class AskCommand extends Command {
         if (/\b(work|gig|errand|hiring|delivery)\b/i.test(topic)) {
             return this.offerWork(target, contact);
         }
+        // "ask <contact> about cleanup" is a PRICE, not a network pull: no
+        // dice and no per-homecoming budget spent. A runner who cannot reach
+        // the Matrix buys the scrub instead of running it
+        // (utilities/cleanup-errand.ts, user 2026-09-15).
+        if (/\b(clean-?up|footage|feeds?|scrub|cameras?)\b/i.test(topic) && this.game) {
+            const quote = cleanupQuoteFor(this.game, target.name, topic.replace(/\b(clean-?up|footage|feeds?|scrub|cameras?|the|at|on|about)\b/gi, '').trim());
+            if (quote)
+                return quote;
+        }
         if (contact.asked) {
             return `${target.name} already worked their network for you since you last went out -- nothing new has come in.${hint(` (Legwork refreshes when you come home from a job.)`)}`;
         }

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

@@ -27,13 +27,13 @@ export const SPRITE_TYPES = {
         name: 'Fault',
         blurb: 'the attack sprite -- a jagged error in the world\'s code that hunts ice',
         combat: l => ({ logic: l + 1, intuition: l, willpower: l + 1, reaction: l + 1, body: 1, agility: 1, strength: 1, charisma: 1,
-            skills: { hacking: l + 1, perception: l } }),
+            skills: { hacking: l + 1, perception: l, cybercombat: l + 1 } }),
     },
     machine: {
         name: 'Machine',
         blurb: 'the device whisperer -- drones, locks, and cameras answer it',
         combat: l => ({ logic: l + 2, intuition: l, willpower: l, reaction: l + 1, body: 1, agility: 1, strength: 1, charisma: 1,
-            skills: { hacking: l, perception: l + 1 } }),
+            skills: { hacking: l, perception: l + 1, hardware: l } }),
     },
 };
 /**

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

@@ -310,6 +310,13 @@ export class HireCommand extends Command {
         // Mechanics panel (ui.ts MENU_VERBS).
         if (args.length === 0)
             return `Hire whom? "crew hire" shows the board.`;
+        // "hire cleanup [<site>]" IS NOT A CREW SEAT (user 2026-09-15). It
+        // buys a shadow decker to scrub a loose end for a runner who cannot
+        // reach the Matrix themselves -- see utilities/cleanup-errand.ts.
+        if (/^clean-?up$/i.test(args[0])) {
+            const { hireCleanupErrand } = await import('../utilities/cleanup-hire.js');
+            return hireCleanupErrand(this.actor, game, args.slice(1).join(' '), this.logger);
+        }
         // ONE TABLE AT A TIME (playtest note): riding another leader's
         // table means their jobs are your jobs -- no building your own
         // crew underneath it. "crew leave" first.

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

@@ -13,6 +13,7 @@ import { gridActionModifier, gridNote } from '../utilities/grids.js';
 import { billAction } from '../utilities/action-cost.js';
 import { MAX_MARKS } from '../utilities/marks.js';
 import { sameHostSide } from '../models/player.js';
+import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
 /** The marks Control Device wants for a Simple device action (p.238). */
 export const MARKS_TO_CONTROL = 2;
 export class DisableCommand extends Command {
@@ -184,8 +185,8 @@ export class DisableCommand extends Command {
         const defenceRoll = rollPool(defence.pool);
         const net = roll.hits - defenceRoll.hits;
         actor.performAction('takes control of a device', name, { quiet: this.scene.isHumanControlled(actor) });
-        if (this.scene.isHumanControlled(actor)) {
-            this.logger.meta(`Control Device (Electronic Warfare + Intuition [Sleaze])${gridNote(grid)}: ${formatRoll(roll)}`);
+        if (showsMechanics(this.scene, actor)) {
+            this.logger.meta(`${mechanicsActorPrefix(this.scene, actor)}Control Device (Electronic Warfare + Intuition [Sleaze])${gridNote(grid)}: ${formatRoll(roll)}`);
             this.logger.meta(`${defence.label}: ${formatRoll(defenceRoll)} -- net ${net >= 0 ? '+' : ''}${net}`);
         }
         const godLines = this.godBill(defenceRoll.hits, 'Control Device (sleaze)');
@@ -240,8 +241,8 @@ export class DisableCommand extends Command {
         const defenceRoll = rollPool(defence.pool);
         const net = roll.hits - defenceRoll.hits;
         actor.performAction('throws a Data Spike', name, { quiet: this.scene.isHumanControlled(actor) });
-        if (this.scene.isHumanControlled(actor)) {
-            this.logger.meta(`Data Spike (Cybercombat + Logic [Attack ${limit}])${gridNote(grid)}: ${formatRoll(roll)}`);
+        if (showsMechanics(this.scene, actor)) {
+            this.logger.meta(`${mechanicsActorPrefix(this.scene, actor)}Data Spike (Cybercombat + Logic [Attack ${limit}])${gridNote(grid)}: ${formatRoll(roll)}`);
             this.logger.meta(`${defence.label}: ${formatRoll(defenceRoll)} -- net ${net >= 0 ? '+' : ''}${net}`);
         }
         const godLines = this.godBill(defenceRoll.hits, 'Data Spike (attack)');
@@ -272,8 +273,8 @@ export class DisableCommand extends Command {
         const dv = limit + net + 2 * marks;
         const soak = rollPool(this.defence(t).pool);
         const dealt = Math.max(0, dv - soak.hits);
-        if (this.scene.isHumanControlled(actor)) {
-            this.logger.meta(`Data Spike -- ${dv} DV (Attack ${limit} +${net} net${marks > 0 ? ` +${2 * marks} for ${marks} mark${marks === 1 ? '' : 's'}` : ''}) v. ${defence.label}: ${formatRoll(soak)} -> ${dealt}`);
+        if (showsMechanics(this.scene, actor)) {
+            this.logger.meta(`${mechanicsActorPrefix(this.scene, actor)}Data Spike -- ${dv} DV (Attack ${limit} +${net} net${marks > 0 ? ` +${2 * marks} for ${marks} mark${marks === 1 ? '' : 's'}` : ''}) v. ${defence.label}: ${formatRoll(soak)} -> ${dealt}`);
         }
         // An Attack action is never subtle: the owner knows.
         this.wakeOwner(t, false);

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

@@ -3,6 +3,7 @@ import { Door } from '../models/door.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { ownedDrones } from '../utilities/owned-drones.js';
 import { droneReconLaunchLine, droneReconNowhereLine, droneReconReturnLine, droneSlipsVents } from '../utilities/drone-prose.js';
+import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
 /**
  * The rigger's mechanic: launch a carried surveillance drone for a live
  * sweep of every room adjacent to this one -- who's there, what's locked,
@@ -42,13 +43,20 @@ export class DroneCommand extends Command {
         // sweep comes back as static -- relaunch and try again.
         const piloting = actor.skillRating('piloting');
         const roll = rollPool(Math.max(1, actor.reaction + (piloting > 0 ? piloting : -1) + actor.bonus('piloting') + actor.woundModifier - actor.sustainingPenalty));
+        // DICE GO TO THE MECHANICS PANEL, like every other test in the engine
+        // (wjFBY3zgyWzJP9adw sweep). This one was written into the prose line
+        // instead -- the only player roll a rigger had to read out of a
+        // sentence.
+        if (showsMechanics(this.scene, actor)) {
+            this.logger.meta(`${mechanicsActorPrefix(this.scene, actor)}Piloting (recon sweep): ${formatRoll(roll)}`);
+        }
         if (roll.hits === 0) {
             return [
-                droneReconLaunchLine(drone, formatRoll(roll), false),
+                droneReconLaunchLine(drone, false),
                 `  It clips a railing, spins, and the feed dissolves into static. It limps home with nothing.`,
             ].join('\n');
         }
-        const lines = [droneReconLaunchLine(drone, formatRoll(roll), true)];
+        const lines = [droneReconLaunchLine(drone, true)];
         for (const [direction, exit] of exits) {
             let target;
             let lockNote = '';

package/bundle/typescript/src/commands/game/sideQuest/commands/edit-file.js

@@ -5,6 +5,7 @@ import { billAction } from '../utilities/action-cost.js';
 import { hostDefensePool } from '../utilities/matrix-intrusion.js';
 import { hostLabel } from '../utilities/grid-names.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
 /**
  * EDIT FILE (SR5 p.239, RAG-checked 2026-09-14): a Complex Action, Marks
  * Required 1, Computer + Logic [Data Processing] v. Intuition + Firewall.
@@ -50,6 +51,17 @@ export class EditFileCommand extends Command {
     }
     async execute(args = []) {
         const actor = this.actor;
+        // "erase mark[s] on <icon>" IS A DIFFERENT ACTION (f79LLqTerep4nKWcA).
+        // Edit File deletes a FILE; Erase Mark (p.239) scrubs a recognition
+        // key, and they share only the English word. The player who types
+        // "erase mark" means the second one, so route it rather than
+        // answering "no file called mark".
+        if (/^marks?$/i.test(args[0] ?? '') || /^marks?$/i.test(args[1] ?? '')) {
+            const { EraseMarkCommand } = await import('./erase-mark.js');
+            return new EraseMarkCommand({
+                actor: this.actor, scene: this.scene, rooms: this.rooms, screen: this.screen, game: this.game,
+            }).execute(args);
+        }
         const { op, word, rest } = this.operation(args);
         if (op !== 'delete') {
             const named = word ? `"${word}"` : 'that';
@@ -79,6 +91,12 @@ export class EditFileCommand extends Command {
         if (!file) {
             return `No file called "${query}" in ${hostLabel(room)}'s archive.${files.length > 0 ? hint(` (It holds: ${files.map(f => f.name).join(', ')}.)`) : ''}`;
         }
+        // HASH (p.257, sprite-power-actions.ts): "only the sprite can
+        // unprotect it" while the algorithm holds. Nothing else edits or
+        // deletes a hashed file -- including its owner.
+        if (file.hashedBy) {
+            return `${file.name} is wrapped in something that is not encryption -- a Resonance algorithm, and it does not answer to Computer. ${hint(`(${file.hashedBy} sealed it. Only ${file.hashedBy} unseals it -- or decompile it and the file is corrupted for good.)`)}`;
+        }
         const marks = room.hostMarksBy.get(actor.name) ?? 0;
         if (marks < 1) {
             return `Edit File needs a MARK (p.239) -- you hold none on ${hostLabel(room)}. ${hint(`"hack" the host for one.`)}`;
@@ -99,8 +117,8 @@ export class EditFileCommand extends Command {
         const defence = hostDefensePool(host);
         const attempt = rollPool(pool, limit, { gremlins: actor.deckGremlins });
         const resist = rollPool(defence.pool);
-        if (this.scene.isHumanControlled(actor)) {
-            this.logger.meta(`Edit File (delete) -- Computer + Logic [Data Processing]: ${formatRoll(attempt)}`);
+        if (showsMechanics(this.scene, actor)) {
+            this.logger.meta(`${mechanicsActorPrefix(this.scene, actor)}Edit File (delete) -- Computer + Logic [Data Processing]: ${formatRoll(attempt)}`);
             this.logger.meta(`  v. ${hostLabel(room)} (${defence.label}, rating standing in for Intuition): ${formatRoll(resist)}`);
         }
         actor.performAction('edits a file', `${file.name} in ${hostLabel(room)}`, { quiet: this.scene.isHumanControlled(actor) });

package/bundle/typescript/src/commands/game/sideQuest/commands/erase-mark.js

@@ -0,0 +1,237 @@
+import { Command } from './command.js';
+import { hint } from '../utilities/hints.js';
+import { rollPool, formatRoll } from '../utilities/dice.js';
+import { billAction } from '../utilities/action-cost.js';
+import { hostDefensePool, overwatchFromDefense } from '../utilities/matrix-intrusion.js';
+import { accrueOverwatch } from '../utilities/overwatch.js';
+import { leaveMatrix } from '../utilities/planes.js';
+import { hostLabel, matchesHostName } from '../utilities/grid-names.js';
+import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { MAX_MARKS } from '../utilities/marks.js';
+import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
+export class EraseMarkCommand extends Command {
+    static verb = 'unmark';
+    static description = 'Erase Mark (Complex Action, SR5 p.239): "unmark me" scrubs the marks others hold on your persona; "unmark <icon>" needs three marks on that icon first. Computer + Logic [Attack] v. Willpower + Firewall. An Attack action -- GOD counts it. Also "erase mark on <icon>".';
+    static npcPolicy = 'authorized';
+    /** p.239: two marks at -4, three at -10; one is unpenalised. */
+    static penaltyFor(count) {
+        if (count >= 3)
+            return -10;
+        if (count === 2)
+            return -4;
+        return 0;
+    }
+    /**
+     * "unmark me" / "unmark <persona>" / "unmark <host>", plus a leading
+     * count: "unmark 2 marks on Deditri". The verb is also reached as
+     * "erase mark[s] on <icon>" (commands/edit-file.ts routes it here),
+     * so the filler words are stripped rather than parsed.
+     */
+    parse(args) {
+        const words = args
+            .map(w => w.toLowerCase())
+            .filter(w => !/^(mark|marks|on|from|off|the|my|a)$/.test(w));
+        let count = 1;
+        if (words.length > 0 && /^[123]$/.test(words[0])) {
+            count = Number(words[0]);
+            words.shift();
+        }
+        return { count, query: words.join(' ').trim() };
+    }
+    resolve(query) {
+        const actor = this.actor;
+        if (query === '' || /^(me|myself|self|persona)$/.test(query)) {
+            return { kind: 'self', player: actor };
+        }
+        const rooms = Object.values(this.scene.getRooms());
+        const host = rooms.find(r => r.hasNode && matchesHostName(query, r));
+        if (host)
+            return { kind: 'host', room: host };
+        const personas = this.scene.allActors.filter(a => a !== actor && a.plane === 'matrix');
+        const picked = fuzzyPickName(query, personas.map(p => p.name));
+        const who = picked ? personas.find(p => p.name === picked) : undefined;
+        if (who)
+            return { kind: 'persona', player: who };
+        return undefined;
+    }
+    /** How many marks the ACTOR holds on the target icon -- the p.239 gate. */
+    marksHeldOn(target) {
+        const actor = this.actor;
+        if (target.kind === 'host')
+            return target.room.host.marksBy.get(actor.name) ?? 0;
+        return target.player.panMarksBy.get(actor.name) ?? 0;
+    }
+    labelFor(target) {
+        if (target.kind === 'host')
+            return hostLabel(target.room);
+        return target.kind === 'self' ? 'your own persona' : `${target.player.name}'s persona`;
+    }
+    /**
+     * Every icon holding a key on the target, each able to give up ONE of
+     * them at a time -- `drop()` decrements, it does not clear the entry.
+     * A multi-mark erase calls it once per mark, which is what makes the
+     * -4/-10 penalties mean anything.
+     *
+     * THE MARKS ON YOU ARE NOT ALL ON ONE LEDGER. A host that made you
+     * keeps its key in Host.marksOn, not in your PAN ledger -- so "unmark
+     * me" has to sweep both, or it would leave the ice's mark exactly where
+     * the player can still see it on their own sheet (utilities/marks.ts
+     * marksOnYou reads the same two places).
+     */
+    placersOn(target) {
+        const actor = this.actor;
+        const out = [];
+        const dec = (m, key) => {
+            const n = (m.get(key) ?? 0) - 1;
+            if (n > 0)
+                m.set(key, n);
+            else
+                m.delete(key);
+        };
+        if (target.kind === 'self') {
+            for (const [placer, count] of actor.panMarksBy.entries()) {
+                if (count > 0)
+                    out.push({ name: placer, count, drop: () => dec(actor.panMarksBy, placer) });
+            }
+            for (const room of Object.values(this.scene.getRooms())) {
+                const host = room.host;
+                const n = host?.marksOn.get(actor.name) ?? 0;
+                if (n > 0 && host) {
+                    out.push({
+                        name: hostLabel(room),
+                        count: n,
+                        drop: () => {
+                            dec(host.marksOn, actor.name);
+                            // A key gone is a sighting gone: an icon it no longer
+                            // recognises is one it has to find again (Host.spotted).
+                            if (!host.marksOn.has(actor.name))
+                                host.spotted.delete(actor.name);
+                        },
+                    });
+                }
+            }
+            return out;
+        }
+        const ledger = target.kind === 'host' ? target.room.host.marksBy : target.player.panMarksBy;
+        for (const [placer, count] of ledger.entries()) {
+            // Your own key is not a mark you "erase" -- p.239 is about reaching
+            // into an icon to scrub somebody ELSE's recognition pattern.
+            if (count > 0 && placer !== actor.name) {
+                out.push({ name: placer, count, drop: () => dec(ledger, placer) });
+            }
+        }
+        return out;
+    }
+    async execute(args = []) {
+        const actor = this.actor;
+        if (actor.plane !== 'matrix') {
+            return `Marks are Matrix keys -- you scrub them with a persona. ${hint(`"jack in" first.`)}`;
+        }
+        const { count, query } = this.parse(args);
+        const target = this.resolve(query);
+        if (!target) {
+            return `No icon here answers to "${query}". ${hint(`("unmark me" for the marks others hold on YOU; "unmark <host or persona>" needs three of your marks on it first.)`)}`;
+        }
+        const label = this.labelFor(target);
+        const held = this.marksHeldOn(target);
+        const placers = this.placersOn(target);
+        if (placers.length === 0) {
+            return target.kind === 'self'
+                ? `Nothing is holding a key on you -- your icon is clean.`
+                : `Nobody else holds a mark on ${label} for you to scrub.`;
+        }
+        // THE THREE-MARK GATE (p.239), waived on your own icon -- see the
+        // owner-exemption ruling in the class comment.
+        if (target.kind !== 'self' && held < MAX_MARKS) {
+            return [
+                `You hold ${held}/${MAX_MARKS} marks on ${label} -- Erase Mark needs THREE on the icon you are scrubbing (p.239), not on whoever placed the mark.`,
+                hint(` ("hack" ${label} up to ${MAX_MARKS}. To clear marks off YOURSELF instead, "unmark me" -- or "reboot"/"jack out", which wipe every mark on you for free, p.242.)`),
+            ].join('');
+        }
+        const wanted = Math.min(count, MAX_MARKS, placers.reduce((n, p) => n + p.count, 0));
+        // p.239: "If you go for more than one mark, all of the marks must be
+        // on the same icon and from the same icon" -- so a multi-mark erase
+        // spends its penalty against ONE placer's keys, not a spread.
+        const chosen = placers.reduce((best, p) => (p.count > best.count ? p : best), placers[0]);
+        const take = Math.min(wanted, chosen.count);
+        const penalty = EraseMarkCommand.penaltyFor(take);
+        const burned = actor.burnedAttributeRefusal('attack');
+        if (burned)
+            return burned;
+        const bill = billAction(this.scene, actor, 'complex', 'Erase Mark', { attack: true });
+        if (bill)
+            return bill;
+        const computer = actor.skillRating('computer');
+        const pool = Math.max(1, actor.logic + (computer > 0 ? computer : -1)
+            + penalty + actor.matrixActionPenalty + actor.woundModifier - actor.sustainingPenalty);
+        const limit = actor.matrixAttribute('attack');
+        const defence = this.defenceFor(target);
+        const attempt = rollPool(pool, limit, { gremlins: actor.deckGremlins });
+        const resist = rollPool(defence.pool);
+        if (showsMechanics(this.scene, actor)) {
+            const many = take > 1 ? ` for ${take} marks (${penalty})` : '';
+            this.logger.meta(`${mechanicsActorPrefix(this.scene, actor)}Erase Mark${many} -- Computer + Logic [Attack]: ${formatRoll(attempt)}`);
+            this.logger.meta(`  ${chosen.name} resists (${defence.label}): ${formatRoll(resist)}`);
+        }
+        actor.performAction('erases a mark', `${chosen.name}'s key on ${label}`, { quiet: this.scene.isHumanControlled(actor) });
+        // AN ATTACK ACTION IS ILLEGAL, and GOD bills the defender's hits
+        // (p.231-232) whether or not it landed.
+        const god = this.godBill(overwatchFromDefense(resist.hits), 'Erase Mark (attack)');
+        if (attempt.hits <= resist.hits) {
+            this.logger.write(`${actor.name} failed Erase Mark on ${label} (${chosen.name}): ${attempt.hits} v ${resist.hits}.`);
+            return [
+                `The key holds. ${chosen.name}'s mark is still written into ${label} and your scrub slides off it.`,
+                hint(` (A Complex Action each try${take > 1 ? `; going for ${take} at once cost you ${penalty} dice` : ''}.)`),
+                ...(god.length > 0 ? [`\n${god.join('\n')}`] : []),
+            ].join('');
+        }
+        for (let i = 0; i < take; i++)
+            chosen.drop();
+        actor.noteConditionChanged();
+        this.scene.updateStatus();
+        this.logger.write(`${actor.name} erased ${take} of ${chosen.name}'s mark(s) on ${label}: ${attempt.hits} v ${resist.hits}.`);
+        const left = this.remainingOn(target, actor);
+        return [
+            `{light-blue-fg}${chosen.name}'s ${take > 1 ? `${take} keys slough` : 'key sloughs'} off ${label} -- the recognition pattern unwrites itself and ${target.kind === 'self' ? 'your icon stops answering to it' : 'the icon forgets it ever agreed'}.{/light-blue-fg}`,
+            target.kind === 'self'
+                ? (left > 0
+                    ? `\n${left} mark${left === 1 ? '' : 's'} still on you.`
+                    : `\nNothing is holding a key on you now.`)
+                : '',
+            ...(god.length > 0 ? [`\n${god.join('\n')}`] : []),
+        ].join('');
+    }
+    /** p.239: Willpower + Firewall. A host has no Willpower; its rating stands in. */
+    defenceFor(target) {
+        if (target.kind === 'host') {
+            const d = hostDefensePool(target.room.host);
+            return { label: `${d.label}, rating standing in for Willpower`, pool: d.pool };
+        }
+        const who = target.player;
+        return {
+            label: 'Willpower + Firewall',
+            pool: Math.max(0, who.willpower + who.matrixAttribute('firewall')),
+        };
+    }
+    remainingOn(target, actor) {
+        if (target.kind !== 'self')
+            return 0;
+        let n = 0;
+        for (const v of actor.panMarksBy.values())
+            n += v;
+        for (const room of Object.values(this.scene.getRooms())) {
+            n += room.host?.marksOn.get(actor.name) ?? 0;
+        }
+        return n;
+    }
+    /** GOD's bill, and the forced dump when it converges -- the shape every
+     *  Attack-action verb in this engine shares (commands/disable.ts). */
+    godBill(defenseHits, why) {
+        const bill = accrueOverwatch(this.scene, this.actor, defenseHits, why);
+        if (bill.converged && this.actor.plane === 'matrix') {
+            bill.lines.push(...leaveMatrix(this.scene, this.actor, { forced: true, reason: `GOD force-reboots your persona --` }));
+        }
+        return bill.lines;
+    }
+}
+//# sourceMappingURL=erase-mark.js.map

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

@@ -13,6 +13,7 @@ import { TapCommand } from './tap.js';
 import { sameHostSide } from '../models/player.js';
 import { MAX_MARKS } from '../utilities/marks.js';
 import { billAction } from '../utilities/action-cost.js';
+import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
 import { declarationPenalty, parseMarkDeclaration, hostDefensePool, wanDefensePool, freeMatrixPerceptionHits, bruteForceMatrixDv, overwatchFromDefense, GO_BIG_QUALITY, deviceDefensePool } from '../utilities/matrix-intrusion.js';
 /**
  * MARKS A PAN INTRUSION MUST ALREADY HOLD before it can command the
@@ -254,8 +255,8 @@ export class HackCommand extends BypassCommand {
                 const bite = rollPool(this.actor.getSoakPool());
                 const dealt = Math.max(0, 3 - bite.hits);
                 // The roll is ticker material; the bite is world (readability pass).
-                if (this.scene.isHumanControlled(this.actor)) {
-                    this.logger.meta(`Firewall: ${formatRoll(bite)}`);
+                if (showsMechanics(this.scene, this.actor)) {
+                    this.logger.meta(`${mechanicsActorPrefix(this.scene, this.actor)}Firewall: ${formatRoll(bite)}`);
                 }
                 const lines = [`The host's defenses snap shut around your intrusion --`];
                 if (dealt > 0) {
@@ -599,9 +600,14 @@ export class HackCommand extends BypassCommand {
         const defense = viaWan ? wanDefensePool(device, host.host) : deviceDefensePool(device);
         const defenseRoll = rollPool(defense.pool);
         const netHits = roll.hits - defenseRoll.hits;
-        if (this.scene.isHumanControlled(actor)) {
+        // THE AUDIENCE, NOT THE ROLLER (wjFBY3zgyWzJP9adw). This asked
+        // whether the actor was human, so an ordered sprite's marks landed
+        // with no dice anywhere -- the exact report. A companion's master
+        // typed the order and is owed its arithmetic.
+        if (showsMechanics(this.scene, actor)) {
             const declaring = declared > 1 ? ` for ${declared} marks (${declarePenalty})` : '';
-            this.logger.meta(`${mode === 'attack' ? 'Brute Force (attack)' : 'Hack on the Fly (sleaze)'} on ${device.name}${declaring}: ${formatRoll(roll)}`);
+            const who = mechanicsActorPrefix(this.scene, actor);
+            this.logger.meta(`${who}${mode === 'attack' ? 'Brute Force (attack)' : 'Hack on the Fly (sleaze)'} on ${device.name}${declaring}: ${formatRoll(roll)}`);
             this.logger.meta(`${defense.label} (DR ${device.rating}): ${formatRoll(defenseRoll)} -- net ${netHits >= 0 ? '+' : ''}${netHits}`);
         }
         const godLines = this.godBill(overwatchFromDefense(defenseRoll.hits), `device intrusion (${mode})`);
@@ -738,9 +744,10 @@ export class HackCommand extends BypassCommand {
         const defense = hostDefensePool(room.host);
         const defenseRoll = rollPool(defense.pool);
         const netHits = roll.hits - defenseRoll.hits;
-        if (this.scene.isHumanControlled(this.actor)) {
+        if (showsMechanics(this.scene, this.actor)) {
             const declaring = declared > 1 ? ` for ${declared} marks (${declarePenalty})` : '';
-            this.logger.meta(`${mode === 'attack' ? 'Brute Force (attack)' : 'Hack on the Fly (sleaze)'}${declaring}${gridNote(grid)}: ${formatRoll(roll)}`);
+            const who = mechanicsActorPrefix(this.scene, this.actor);
+            this.logger.meta(`${who}${mode === 'attack' ? 'Brute Force (attack)' : 'Hack on the Fly (sleaze)'}${declaring}${gridNote(grid)}: ${formatRoll(roll)}`);
             this.logger.meta(`${defense.label}: ${formatRoll(defenseRoll)} -- net ${netHits >= 0 ? '+' : ''}${netHits}`);
         }
         return { success: netHits > 0, netHits, defenseHits: defenseRoll.hits };
@@ -853,9 +860,11 @@ export class HackCommand extends BypassCommand {
         actor.performAction('runs a PAN intrusion', target.name, { quiet: this.scene.isHumanControlled(actor) });
         this.logger.write(`${actor.name} PAN-hacks ${target.name}: ${attack.hits} vs ${defense.hits} (silent=${target.runningSilent}).`);
         // Dice anatomy to the Mechanics ticker (readability pass) --
-        // player-gated like every roll site: an NPC's probe isn't your dice.
-        if (this.scene.isHumanControlled(actor)) {
-            this.logger.meta(`PAN intrusion (${mode === 'attack' ? 'brute force' : 'sleaze'}${markDice > 0 ? `, +${markDice} marks` : ''})${noiseNote(noise)}${gridNote(grid)}: ${formatRoll(attack)}`);
+        // audience-gated: a passer-by's probe isn't your dice, but the agent
+        // YOU set on a PAN is (showsMechanics).
+        if (showsMechanics(this.scene, actor)) {
+            const who = mechanicsActorPrefix(this.scene, actor);
+            this.logger.meta(`${who}PAN intrusion (${mode === 'attack' ? 'brute force' : 'sleaze'}${markDice > 0 ? `, +${markDice} marks` : ''})${noiseNote(noise)}${gridNote(grid)}: ${formatRoll(attack)}`);
             this.logger.meta(`  their firewall: ${formatRoll(defense)}`);
         }
         // GOD counts the defender's hits as evidence (canon p.231-232) --
@@ -1023,8 +1032,8 @@ export class HackCommand extends BypassCommand {
         // seed's enforcer still fumbles terminals about like it used to.
         const pool = Math.max(1, this.actor.logic + this.actor.skillRating('hacking') + this.actor.bonus('hacking') + this.actor.woundModifier - this.actor.sustainingPenalty);
         const roll = rollPool(pool, undefined, { gremlins: this.actor.deckGremlins });
-        if (this.scene.isHumanControlled(this.actor)) {
-            this.logger.meta(`Hacking: ${formatRoll(roll)} (2+ to crack)`);
+        if (showsMechanics(this.scene, this.actor)) {
+            this.logger.meta(`${mechanicsActorPrefix(this.scene, this.actor)}Hacking: ${formatRoll(roll)} (2+ to crack)`);
         }
         return roll.hits >= 2;
     }

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

@@ -7,6 +7,7 @@ import { billAction, encounterOf } from '../utilities/action-cost.js';
 import { isSpotted } from '../utilities/ic.js';
 import { MAX_MARKS } from '../utilities/marks.js';
 import { hostLabel } from '../utilities/grid-names.js';
+import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
 /**
  * HIDE (SR5 p.240, RAG-checked 2026-09-14): a Complex Action, no marks
  * required, Electronic Warfare + Intuition [Sleaze] v. Intuition + Data
@@ -67,8 +68,8 @@ export class HideCommand extends Command {
         const limit = actor.matrixAttribute('sleaze');
         const attempt = rollPool(pool, limit, { gremlins: actor.deckGremlins });
         const defence = rollPool(room.hostRating + room.hostAttributes().dataProcessing);
-        if (this.scene.isHumanControlled(actor)) {
-            this.logger.meta(`Hide -- Electronic Warfare + Intuition [Sleaze]: ${formatRoll(attempt)}`);
+        if (showsMechanics(this.scene, actor)) {
+            this.logger.meta(`${mechanicsActorPrefix(this.scene, actor)}Hide -- Electronic Warfare + Intuition [Sleaze]: ${formatRoll(attempt)}`);
             this.logger.meta(`  v. ${hostLabel(room)} (Host Rating + Data Processing, rating standing in for Intuition): ${formatRoll(defence)}`);
         }
         actor.performAction('tries to hide', `persona folding into ${hostLabel(room)}'s traffic`, { quiet: this.scene.isHumanControlled(actor) });

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

@@ -4,6 +4,7 @@ import { enterMatrix, leaveMatrix } from '../utilities/planes.js';
 import { hint } from '../utilities/hints.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { billAction } from '../utilities/action-cost.js';
+import { showsMechanics } from '../utilities/mechanics-audience.js';
 /**
  * The Matrix door, both directions: "jack in [hot|cold]" and "jack out".
  * Needs a working CYBERDECK carried (a commlink is calls and AR only) --
@@ -65,7 +66,7 @@ export class JackCommand extends Command {
         const lines = [
             `You throw everything at the disconnect --`,
         ];
-        if (this.scene.isHumanControlled(actor)) {
+        if (showsMechanics(this.scene, actor)) {
             this.logger.meta(firewall > 0
                 ? `Jack Out -- Hardware + Willpower [Firewall]: ${formatRoll(attempt)}`
                 : `Jack Out -- Hardware + Willpower, UNBRACKETED (no functional Firewall left, p.229): ${formatRoll(attempt)}`);
@@ -73,7 +74,7 @@ export class JackCommand extends Command {
         const held = [];
         for (const name of lockers) {
             const hold = rollPool(room.hostRating * 2, room.hostAttributes().attack);
-            if (this.scene.isHumanControlled(actor)) {
+            if (showsMechanics(this.scene, actor)) {
                 this.logger.meta(`  v. ${name} keep-alive (Host Rating x2 [Attack]): ${formatRoll(hold)}`);
             }
             // Ties go to the locker: you need to BEAT each of them.

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

@@ -18,6 +18,7 @@ import { spotsActive, whoIsWhereLine, highlightSpots, highlightActors, canReach,
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { findCatalogItem, describeEffect } from '../utilities/catalog.js';
 import { billAction } from '../utilities/action-cost.js';
+import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
 export class LookCommand extends Command {
     static verb = 'look';
     static description = 'Examine your surroundings';
@@ -166,8 +167,8 @@ export class LookCommand extends Command {
             // the two verbs cannot drift apart again.
             const { pool, limit } = perceptionTest(this.actor);
             const roll = rollPool(pool, limit);
-            if (this.scene.isHumanControlled(this.actor)) {
-                this.logger.meta(`Perception (look): ${formatRoll(roll)} (2+ spots partial cover, 4+ good)`);
+            if (showsMechanics(this.scene, this.actor)) {
+                this.logger.meta(`${mechanicsActorPrefix(this.scene, this.actor)}Perception (look): ${formatRoll(roll)} (2+ spots partial cover, 4+ good)`);
             }
             const who = whoIsWhereLine(room, this.actor, roll.hits);
             if (who)

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

@@ -182,16 +182,26 @@ export class OrderCommand extends Command {
         // task, then the fight's own per-fight charge found the bargain
         // already at zero and dismissed the spirit mid-lunge.
         const isAttackOrder = /\b(attack|kill|subdue|fight|slay|destroy)\b/i.test(cmd);
-        const billsService = entry.kind === 'spirit' && !isAttackOrder;
-        if (billsService && (entry.services ?? 0) <= 0) {
-            return `${entry.npc.name} regards you flatly. The bargain is spent -- no services remain.`;
+        // A SPRITE'S TASKS ARE A BARGAIN TOO (wjFBY3zgyWzJP9adw). This billed
+        // spirits only, so an ordered sprite worked for free and its ledger
+        // line never printed -- while combat-exchange.ts has always charged
+        // BOTH kinds per fight. Canon is explicit: a compiled sprite owes
+        // (hits) tasks and "using a power costs one task" (p.254, p.256).
+        // The vocabulary differs -- a spirit owes services, a sprite tasks --
+        // so the line says which.
+        const billsTask = (entry.kind === 'spirit' || entry.kind === 'sprite') && !isAttackOrder;
+        const owed = entry.kind === 'sprite' ? 'task' : 'service';
+        if (billsTask && (entry.services ?? 0) <= 0) {
+            return entry.kind === 'sprite'
+                ? `${entry.npc.name} flickers and does not move. Its tasks are spent -- compile or register another.`
+                : `${entry.npc.name} regards you flatly. The bargain is spent -- no services remain.`;
         }
         const chargeService = () => {
-            if (!billsService)
+            if (!billsTask)
                 return;
             entry.services = (entry.services ?? 0) - 1;
             // Resource arithmetic -- Mechanics ticker (readability pass).
-            this.logger.meta(`👥 One service spent (${entry.services} left).`, 'green');
+            this.logger.meta(`👥 ${entry.npc.name}: one ${owed} spent (${entry.services} left).`, 'green');
         };
         // Tier 1 -- ATOMIC: a known command runs deterministically, no AI.
         // A parsed command whose RESULT is a refusal is NOT obedience: a real

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

@@ -2,6 +2,7 @@ import { Command } from './command.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { accrueOverwatch, settledScore, CONVERGENCE_AT } from '../utilities/overwatch.js';
 import { leaveMatrix } from '../utilities/planes.js';
+import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
 /**
  * Check Overwatch Score (canon p.238): Electronic Warfare + Logic
  * [Sleaze] vs GOD's flat 6 dice. Win the read and you see the exact
@@ -40,8 +41,8 @@ export class OverwatchCommand extends Command {
         // (canon p.235-236, Player.matrixActionPenalty).
         const mine = rollPool(Math.max(1, actor.logic + (skill > 0 ? skill : -1) + actor.matrixActionPenalty + actor.woundModifier - actor.sustainingPenalty), limit);
         const god = rollPool(6);
-        if (this.scene.isHumanControlled(actor)) {
-            this.logger.meta(`Check Overwatch (EW, sleaze): ${formatRoll(mine)}`);
+        if (showsMechanics(this.scene, actor)) {
+            this.logger.meta(`${mechanicsActorPrefix(this.scene, actor)}Check Overwatch (EW, sleaze): ${formatRoll(mine)}`);
             this.logger.meta(`  GOD's counter-sweep: ${formatRoll(god)}`);
         }
         // The number they glimpse is the score BEFORE this check's own bill