@maka/maka-cli 5.199.0 → 5.201.0

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

@@ -8,6 +8,7 @@ import { hostLabel } from '../utilities/grid-names.js';
 import { canReach, exitSpot, spotsActive, revealWithPerception, theSpot, sealedRouteTo, } from '../utilities/spots.js';
 import { placeName } from '../utilities/log-style.js';
 import { billAction, encounterOf } from '../utilities/action-cost.js';
+import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
 /**
  * Barrier rendering (2026-08-24 playtest: "I don't see THE THING I'm
  * supposed to act on -- just a description... and I still see the
@@ -166,9 +167,8 @@ export class SearchCommand extends Command {
         const { pool, limit } = matrixSearchTest(actor);
         const roll = rollPool(pool, limit);
         const seconds = matrixSearchSeconds(row.seconds, roll.hits, row.threshold, browse);
-        const isPlayer = this.scene.isHumanControlled(actor);
-        if (isPlayer) {
-            this.logger.meta(`Matrix Search (Computer + Intuition [Data Processing], threshold ${row.threshold}${browse ? ', Browse' : ''}): ${formatRoll(roll)} -- ${seconds}s`);
+        if (showsMechanics(this.scene, actor)) {
+            this.logger.meta(`${mechanicsActorPrefix(this.scene, actor)}Matrix Search (Computer + Intuition [Data Processing], threshold ${row.threshold}${browse ? ', Browse' : ''}): ${formatRoll(roll)} -- ${seconds}s`);
         }
         // THE MINUTES ARE GOD'S (p.231-232): Overwatch bills time on the
         // grid, and a search is time. Winding the last tick back by the
@@ -176,7 +176,12 @@ export class SearchCommand extends Command {
         if (actor.overwatchLastTick > 0)
             actor.overwatchLastTick -= seconds * 1000;
         actor.performAction('runs a Matrix Search', host ? `inside ${hostLabel(where)}` : `across ${where.name}'s grid`, { quiet: this.scene.isHumanControlled(actor) });
-        const files = where.offlineServer ? [] : where.inventory.getAllItems().filter(i => i.plane === 'matrix');
+        // CAMOUFLAGE (p.256, sprite-power-actions.ts): a file a sprite folded
+        // into another file is "invisible to Matrix searches" -- only a Matrix
+        // Perception specifically hunting it turns it up. This is the search
+        // it is invisible to.
+        const files = where.offlineServer ? [] : where.inventory.getAllItems()
+            .filter(i => i.plane === 'matrix' && !i.concealedBy);
         const clock = `(${seconds}s of Matrix time${browse ? ', Browse cutting it' : ''})`;
         if (roll.hits < row.threshold) {
             return host
@@ -210,8 +215,24 @@ export class SearchCommand extends Command {
         // minute inside a host), not in Action Phases -- there is no cost to
         // bill inside a Combat Turn, so it is refused there rather than
         // priced by invention.
-        if (this.actor.plane === 'matrix' && encounterOf(this.scene, this.actor)) {
-            return `Not with the ice on you -- a Matrix Search takes minutes (p.241), and a Combat Turn is three seconds. Crash the ice, "hide" from it (p.240), or get out first.`;
+        //
+        // A FINISHED FIGHT IS NOT A FIGHT. This asked `encounterOf(...)` and
+        // nothing else, while every other seam in action-cost.ts -- billAction,
+        // requirePhase, inLiveCombat -- pairs it with `!enc.ended`. An
+        // encounter object outlives the fight it ran, so a persona that had
+        // crashed the ice and watched the walls come down kept being told to
+        // crash the ice: the refusal named an exit the player had already
+        // taken. That is the reported "it says I can't do it with an IC
+        // there" (user, 2026-09-15), and the reason the answer to "is that
+        // correct?" is yes-but-not-here.
+        const enc = encounterOf(this.scene, this.actor);
+        if (this.actor.plane === 'matrix' && enc && !enc.ended) {
+            // Name the action that DOES fit in three seconds. The old line
+            // listed only ways to leave, which reads as "not now" when canon's
+            // answer is "not this verb" -- Matrix Perception is the Complex
+            // Action for looking at things mid-fight, and `look` is it
+            // (commands/look.ts bills exactly that).
+            return `Not with the ice on you -- a Matrix Search takes minutes (p.241), and a Combat Turn is three seconds. "look" is Matrix Perception (p.241), the Complex Action you CAN take right now. Otherwise crash the ice, "hide" from it (p.240), or get out first.`;
         }
         if (this.actor.plane === 'matrix')
             return this.matrixSearch();
@@ -238,10 +259,15 @@ export class SearchCommand extends Command {
         // Roll anatomy to the Mechanics ticker for the player; an NPC's
         // return string is its AI history, so IT keeps the roll inline
         // (readability pass).
-        const isPlayer = this.scene.isHumanControlled(this.actor);
-        if (isPlayer)
-            this.logger.meta(`Perception: ${formatRoll(roll)}`);
-        const rollPrefix = isPlayer ? '' : `Perception: ${formatRoll(roll)}\n`;
+        // ONE PREDICATE FOR BOTH HALVES. The roll goes to the Mechanics panel
+        // OR into the return string (an NPC's AI history), never both -- so
+        // when the gate widened to companions (showsMechanics), the inline
+        // copy had to narrow by exactly the same amount or an ordered drone
+        // would print its Perception twice.
+        const toPanel = showsMechanics(this.scene, this.actor);
+        if (toPanel)
+            this.logger.meta(`${mechanicsActorPrefix(this.scene, this.actor)}Perception: ${formatRoll(roll)}`);
+        const rollPrefix = toPanel ? '' : `Perception: ${formatRoll(roll)}\n`;
         if (roll.hits === 0) {
             return `${rollPrefix}You sweep the room and come up empty... you think.${describeContainers(room, this.actor)}${describeBarriers(room, this.actor)}`;
         }

package/bundle/typescript/src/commands/game/sideQuest/commands/sprite-power.js

@@ -0,0 +1,85 @@
+import { Command } from './command.js';
+import { hint } from '../utilities/hints.js';
+import { NPC } from '../models/npc.js';
+import { SPRITE_POWERS, SPRITE_POWER_TASK_RULE, powersForSprite } from '../sprite-powers.js';
+import { runSpritePower } from '../utilities/sprite-power-actions.js';
+/**
+ * A SPRITE POWER AS A TYPED MOVE (user 2026-09-15).
+ *
+ * The verb surface is `order <sprite> <power> [target]` -- order.ts
+ * already parses "order <name> <command>" and hands the rest to
+ * NPC.tryRunCommand, so each power name registers as an ordinary verb
+ * that only a sprite can run. That keeps the task accounting, the
+ * companion feed and the Mechanics routing that "order" already does,
+ * instead of building a second way to tell a sprite to do something.
+ *
+ * ONE TASK PER USE (p.254, p.256 -- SPRITE_POWER_TASK_RULE). order.ts
+ * bills it on the success path, so a refusal here costs nothing. That is
+ * why every guard below returns before the resolver runs.
+ */
+export class SpritePowerCommand extends Command {
+    static verb = 'cookie';
+    static description = 'A sprite power (SR5 p.256-257). Order it: "order <sprite> <power> <target>". "sprites" lists which sprite has which.';
+    static npcPolicy = 'open';
+    /** Which power this registration is -- set per alias at registration. */
+    powerKey() {
+        return this.constructor.verb;
+    }
+    async execute(args = []) {
+        const actor = this.actor;
+        const key = this.powerKey();
+        // A PERSON CANNOT DO THESE. Sprite powers are the thing a sprite has
+        // that its technomancer does not (Sz7EmXnyRYK4RYqxt's whole point),
+        // so a player typing "cookie" is told where the verb lives rather
+        // than being quietly refused by a type check.
+        if (!(actor instanceof NPC)) {
+            const power = SPRITE_POWERS.find(p => p.key === key);
+            return `${power?.name ?? key} is a SPRITE power (${power?.page ?? 'p.256-257'}) -- not something a persona does. ${hint(`Order it: "order <sprite> ${key} <target>". "sprites" shows which sprite has which.`)}`;
+        }
+        const game = this.scene.ownerGame;
+        const entry = game?.companions?.find(c => c.npc === actor);
+        if (!entry || entry.kind !== 'sprite') {
+            return `Only a sprite runs a sprite power (p.256).`;
+        }
+        const spriteKey = entry.spriteType ?? '';
+        const master = this.scene.getPlayers?.()[0];
+        if (!master)
+            return `No one is holding this sprite's thread.`;
+        // The p.259 database decides who has what; the resolver re-checks,
+        // but naming the sprite's own list here is the useful refusal.
+        if (!powersForSprite(spriteKey).some(p => p.key === key)) {
+            const mine = powersForSprite(spriteKey).map(p => p.name).join(', ');
+            return `${actor.name} is a ${spriteKey} sprite -- no ${SPRITE_POWERS.find(p => p.key === key)?.name ?? key} (p.259). It can do: ${mine || 'nothing listed'}.`;
+        }
+        // DIAGNOSTICS TAKES THE SPRITE'S WHOLE ATTENTION (p.257): any other
+        // order drops the bonus it was holding. Cleared before the new power
+        // runs, so the sprite cannot be assisting and attacking at once.
+        if (master.spriteAssist?.sprite === actor.name && key !== 'diagnostics') {
+            master.spriteAssist = undefined;
+        }
+        const result = runSpritePower(key, {
+            scene: this.scene,
+            sprite: actor,
+            level: entry.force,
+            spriteKey,
+            master,
+        }, args.join(' '));
+        for (const line of result.meta)
+            this.logger.meta(line);
+        if (!result.spent)
+            return result.text;
+        this.scene.updateStatus?.();
+        return `${result.text}${hint(`\n${SPRITE_POWER_TASK_RULE}`)}`;
+    }
+}
+/** One registered verb per power, so "order <sprite> gremlins <lock>" parses
+ *  through the ordinary command table rather than a second dispatcher. */
+export const SPRITE_POWER_COMMANDS = Object.fromEntries(SPRITE_POWERS.map(power => {
+    const cls = class extends SpritePowerCommand {
+        static verb = power.key;
+        static description = `${power.name} (${power.page}): ${power.effect}`;
+        powerKey() { return power.key; }
+    };
+    return [power.key, cls];
+}));
+//# sourceMappingURL=sprite-power.js.map

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

@@ -82,7 +82,14 @@ export class SpritesCommand extends Command {
                 continue;
             }
             for (const p of powers) {
-                lines.push(`  ${p.name}${hint(`  (${p.page})`)}`);
+                // WHICH POWERS ARE MOVES (ISpritePower.runnable). Eight of the
+                // nine resolve; Stability is still catalogue, and the panel says
+                // so on the power itself rather than letting a player find out
+                // by typing it -- a wrong ability is worse than a missing one.
+                const how = p.runnable
+                    ? hint(`  -- "order <sprite> ${p.key} <target>"`)
+                    : `  {yellow-fg}(reference only -- not a move yet){/yellow-fg}`;
+                lines.push(`  ${p.name}${hint(`  (${p.page})`)}${how}`);
                 lines.push(`      ${p.effect}`);
                 // The Test line is the sharpest thing on the panel for a player
                 // deciding between two types -- it says what the power rolls
@@ -95,8 +102,10 @@ export class SpritesCommand extends Command {
         }
         const footer = [
             SPRITE_POWER_TASK_RULE,
-            // Said plainly, not buried: see the class comment.
-            `These powers are CANON REFERENCE -- none is a move you can type yet. What a compiled sprite actually does today is fight ice at your side and take "order".`,
+            // Said plainly, not buried: see the class comment. Eight of the
+            // nine became real moves on 2026-09-15; Stability did not, and the
+            // footer is not allowed to round that up.
+            `Order a power like any other command: "order <sprite> <power> <target>". Stability alone is still reference -- it is listed because canon has it, not because it does anything yet.`,
             detailed ? `"sprites" lists all five.` : `"sprites <type>" for what each power actually does. "compile <type> <level>" calls one up.`,
         ].join(' ');
         const tail = hint(footer);

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

@@ -5,6 +5,7 @@ import { accrueOverwatch } from '../utilities/overwatch.js';
 import { MAX_MARKS } from '../utilities/marks.js';
 import { isWatched, cameraMasterHost, directConnectionBlocker } from '../utilities/surveillance.js';
 import { hint } from '../utilities/hints.js';
+import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
 /**
  * TAP -- THE DIRECT CONNECTION (backlog items 9 and 10, Niko, session
  * 2026-08-27T02-07-12-404Z: "check the rules on this -- shouldn't I be
@@ -103,8 +104,8 @@ export class TapCommand extends Command {
         const pool = Math.max(1, actor.logic + actor.skillRating('hacking') + actor.bonus('hacking') + silence + actor.woundModifier - actor.sustainingPenalty);
         actor.performAction('cables into the cameras', `${room.name} -- a hand on the housing, a filament out of their deck`);
         const roll = rollPool(pool, limit);
-        if (this.scene.isHumanControlled(actor)) {
-            this.logger.meta(`Direct connection, camera (${mode === 'attack' ? 'brute force' : 'sleaze'}): ${formatRoll(roll)} (${threshold}+ -- its OWN ratings, not the host's)`);
+        if (showsMechanics(this.scene, actor)) {
+            this.logger.meta(`${mechanicsActorPrefix(this.scene, actor)}Direct connection, camera (${mode === 'attack' ? 'brute force' : 'sleaze'}): ${formatRoll(roll)} (${threshold}+ -- its OWN ratings, not the host's)`);
         }
         this.logger.write(`${actor.name} direct-connected to ${room.name}'s cameras (${mode}): ${roll.hits} vs ${threshold}, master=${host.name}.`);
         // GOD counts it either way (p.231-232) -- the same flat 2 a host

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

@@ -577,5 +577,143 @@
 //   - BENCH: repro schema 2.6.0 adds npcs[].hostile. A fixture could not
 //     express a hostile PERSON -- only `ice` -- so no meat-side
 //     hostility report could be benched at all.
-export const ENGINE_VERSION = '1.58.0';
+// 1.59.0 (2026-09-15): A HOST'S BUSINESS IS SOMETHING YOU SEARCH FOR.
+//   - THE PURPOSE PHRASE IS ARCHIVE CONTENT (np6YBSPsdfAY7NcuZ). The
+//     generator is told to fill Host.purpose with "what is worth
+//     protecting inside it", so in practice it enumerates the vault --
+//     "patient intake logs, med supply orders, and the doc's private
+//     black book of who paid what for what" -- and four renderers
+//     printed that on a SEALED host's outside icon for free, while the
+//     file names beside it were correctly gated. Two tiers now, both
+//     rolls the engine already made: Room.searchedBy (the threshold-1
+//     public row, or a meat search of the room) reveals the business;
+//     Host.searchedBy (threshold 3, from inside) still names the files.
+//     A cracked host spills both. One gate, grid-names.hostPurposeFor,
+//     read by hostLine, gridIcons, gridSculpt and hostInteriorPanel.
+//     The dock's "N files sealed" counter was ungated too and is now.
+//   - SAVE SHAPE: ISavedRoomOverlay.hostSearchedBy (optional) persists
+//     Host.searchedBy, which was session-only. Survivable while it hid
+//     a file list; not once it gates the purpose, because the search
+//     that opens it spends Matrix minutes and those minutes wind the
+//     Overwatch clock. A reload was charging the player twice.
+//   - A FINISHED FIGHT IS NOT A FIGHT. Matrix Search's Combat Turn
+//     refusal asked `encounterOf(...)` alone, while billAction,
+//     requirePhase and inLiveCombat all pair it with `!enc.ended` -- so
+//     a persona that had already crashed the ice kept being told to
+//     crash the ice. The refusal is correct in a LIVE fight (base time
+//     one minute, p.241, against a three-second Combat Turn) and now
+//     also names the action that does fit: Matrix Perception, which is
+//     `look`.
+//   - Browse's catalogue blurb promised "+2 dice on Matrix Search" and
+//     no code ever granted them; it halves the base TIME (Splintered
+//     State p.54), which is what perception.ts has always done.
+// 1.60.0 (2026-09-15): THE MECHANICS PANEL ASKS WHO IS WATCHING.
+//   - AN ORDERED COMPANION'S DICE WERE ROLLED AND THROWN AWAY
+//     (wjFBY3zgyWzJP9adw). `order <sprite> mark <lock>` runs the real
+//     verb with the sprite as actor and rolls Hack on the Fly exactly as
+//     a decker would -- then ~30 commands dropped the result on the
+//     floor, because the guard around every logger.meta asked
+//     `isHumanControlled(actor)`: is the ROLLER a human. The panel wants
+//     "is a human WATCHING", which combat-exchange has always asked
+//     (playerWitnesses) -- which is why a sprite's COMBAT rolls showed
+//     and its ordered mark did not. New utilities/mechanics-audience.ts:
+//     showsMechanics is true for a human OR a companion a human is
+//     running, and the line names the roller when it is not the player.
+//     Swept across hack, disable, edit-file, hide, jack, overwatch, tap,
+//     look and search -- sprites, spirits, agents and drones alike.
+//     Where a command forked meta-vs-inline on the old predicate, BOTH
+//     halves moved, so nothing prints twice.
+//   - A SPRITE'S TASKS ARE A BARGAIN TOO. order.ts billed services for
+//     spirits only, so an ordered sprite worked free and its ledger line
+//     never printed -- while combat-exchange has always charged both per
+//     fight. Canon is explicit (p.254, p.256): a task per order, and the
+//     refusal when the thread is spent now speaks sprite, not spirit.
+//   - The un-jumped drone recon's Piloting test wrote its dice into the
+//     PROSE line (drone-prose.droneReconLaunchLine took a rollText) --
+//     the one player roll in the engine you had to read out of a
+//     sentence. It goes to the panel; the prose is prose again.
+// 1.61.0 (2026-09-15): ERASE MARK (f79LLqTerep4nKWcA). New verb
+//   "unmark", also reached as "erase mark[s] on <icon>" -- a Complex
+//   Action, Computer + Logic [Attack] v. Willpower + Firewall (p.239),
+//   an ATTACK action so GOD bills the defender's hits. Nothing removed a
+//   mark before this: the only paths were the three canon wipes in
+//   utilities/marks.ts (reboot, jack-out, convergence), and `erase` was
+//   Edit File's delete on a FILE.
+//   - THE THREE-MARK GATE is the book's: you need three marks on the
+//     icon you are scrubbing, not on whoever placed the mark. Two marks
+//     in one action at -4, three at -10, all from the same icon.
+//   - THE OWNER EXEMPTION IS AN ENGINE RULING, labelled as one at the
+//     command. Read strictly, p.239 would make a decker mark themselves
+//     three times before clearing an IC's key off their own persona --
+//     marks nothing in the engine or the book lets you place on
+//     yourself. The gate stops you reaching into someone ELSE's icon;
+//     on your own it is waived and the roll still stands. When you hold
+//     too few marks to reach another icon, the refusal names reboot and
+//     jack out, which do it for free.
+//   - "unmark me" sweeps BOTH ledgers -- a host's key lives in
+//     Host.marksOn, not your PAN ledger -- and clearing a host's last
+//     key un-spots you (Host.spotted): an icon it no longer recognises
+//     is one it has to find again.
+//   - TWO LEDGER BUGS ALONGSIDE. Device.marksBy is the third mark
+//     ledger and no wipe had ever touched it, so a maglock you keyed
+//     last run still answered to a persona canon deleted on reboot
+//     (p.236) -- and `disable` could drive it on marks the sheet no
+//     longer showed. It is cleared by clearMarksPlacedBy now, and
+//     listed by describeMarks/marksPlaced, which had both skipped it.
+// 1.62.0 (2026-09-15): HIRING THE SCRUB. A runner who cannot reach the
+//   Matrix can now pay somebody who can. "ask <contact> about cleanup"
+//   quotes a price (no dice, no legwork budget spent); "hire cleanup
+//   [<site>]" haggles it once on Negotiation, debits the nuyen and
+//   stamps the loose end. The decker's own test rolls at the NEXT
+//   homecoming -- you paid for a result you do not get to watch.
+//   Clean, leverage (done, but they kept a copy) or botched (footage
+//   stays, grace clock keeps running, no refund).
+//   - WHY: a run leaves an ILooseEnd and the hub nagged EVERY runner to
+//     "jack in, then hop" and erase it -- a route that needs a cyberdeck
+//     and a direct neural interface. A street samurai was handed a
+//     consequence with no lever and a +1 Public Awareness on a timer.
+//     The playable cleanup scene is untouched; this is the other door.
+//   - SAVE SHAPE: ILooseEnd.hired (optional, additive -- no
+//     SAVE_VERSION bump). It rides the record that was already
+//     persisted, so a job already paid for survives a reload, and the
+//     fixer's Connection + Loyalty is BANKED at hire time so a loyalty
+//     shift in between cannot retroactively change it.
+//   - New Player.canReachMatrix(), the question commands/jack.ts answers
+//     in three separate refusals, asked once so the hub's advice can be
+//     written for the runner reading it.
+// 1.63.0 (2026-09-15): SPRITE POWERS ARE MOVES. sprite-powers.ts has
+//   been a canon-complete, individually cited catalogue of all nine
+//   since Sz7EmXnyRYK4RYqxt -- and every one was a printed Test line
+//   wired to nothing. Eight of them resolve now
+//   (utilities/sprite-power-actions.ts), keyed off the same five sprite
+//   keys so the panel and the mechanics cannot drift. Ordered like any
+//   other command: "order <sprite> <power> <target>", one TASK per use
+//   (p.254/p.256), billed on success so a refusal is free.
+//     Cookie          Hacking + Resonance [Sleaze] v. Intuition+Firewall
+//     Diagnostics     Hardware + Level [Data Processing], Teamwork
+//     Electron Storm  Cybercombat + Resonance [Attack], sustained
+//     Gremlins        Hardware + Level [Attack] v. Device Rating+Firewall
+//     Camouflage / Hash / Suppression / Watermark -- state, no roll
+//   - NEW CANON DATA: a sprite's four Matrix attributes are PER TYPE
+//     (p.259) and only Resonance equals Level (p.254). The engine had no
+//     table, which is fine while a power is a printed string and not
+//     fine the moment it needs a [Sleaze] number -- a bracket is a LIMIT.
+//     spriteMatrix()/spriteMatrixBoxes() carry it. Fault sprites gain
+//     Cybercombat and machine sprites Hardware, the skills p.259 already
+//     listed on the panel and compile.ts never gave the shell.
+//   - CONSUMERS: Camouflage hides a file from Matrix Search
+//     (commands/search.ts); Hash blocks Edit File; Suppression delays the
+//     host's launch step (utilities/host-combat.ts hostTurnStart);
+//     Electron Storm ends on any Matrix damage to the sprite, enforced on
+//     Player.takeMatrixDamage -- the one method every Matrix hit goes
+//     through. New session state: Item.concealedBy/hashedBy/watermark,
+//     Host.icLaunchDelay, Player.cookiedBy/spriteAssist, NPC.sustainedStorm.
+//   - STABILITY IS DELIBERATELY NOT WIRED, and both the catalogue and the
+//     panel say so per-power (ISpritePower.runnable). It demotes
+//     glitches, and glitches are read at sixteen scattered sites in this
+//     engine; wiring it at three would be a power that works where
+//     somebody happened to look -- the "wrong ability on a sprite is
+//     worse than a missing one" case. It wants the glitch contract in one
+//     place first, and that is its own piece of work.
+export const ENGINE_VERSION = '1.63.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -12,6 +12,9 @@ import { hostInteriorPanel } from './utilities/grid-view.js';
 import { DEFAULT_GRID_PROVIDER, PUBLIC_GRID, globalGrid, looseEndGrid } from './utilities/grids.js';
 import { buildCleanupSeed } from './factories/cleanup-seed.js';
 import { EditFileCommand, EraseCommand } from './commands/edit-file.js';
+import { EraseMarkCommand } from './commands/erase-mark.js';
+import { SPRITE_POWER_COMMANDS } from './commands/sprite-power.js';
+import { cleanupOutcome } from './utilities/cleanup-errand.js';
 import { hostsInReach, hostDockLine, gridVicinity } from './utilities/grid-reach.js';
 import { nameThem, scrubHandles } from './utilities/identity.js';
 import { dirname } from 'path';
@@ -24,7 +27,7 @@ import { SAVE_VERSION } from './types/save-file.js';
 import { hubSeedRefOf } from './utilities/hub-seed.js';
 import { serializePlayer, restorePlayer, captureHubOverlay, applyHubOverlay, applyHomeBlock, writeSaveAtomic, deleteSave, restoreItem, readSave, serializeItem, saveSlug, spillPathFor, } from './utilities/persistence.js';
 import { heartbeatPresence, heartbeatPresenceNow } from './utilities/social.js';
-import { presenceBeatAllowed } from './utilities/presence-gate.js';
+import { presenceBeatAllowed, presenceProcessOnTheStreet } from './utilities/presence-gate.js';
 import { pushSave, burnCloudSaveFor, enqueueBoundPush, flushPushQueue, writeSpill, takeLastMemorial, authToken, clearSpill, hasPendingPush, } from './utilities/cloud-saves.js';
 import { DOCWAGON_TIERS, RESUSC_FEE, DEATH_COMP } from './utilities/docwagon.js';
 import { isFence, LIFESTYLE_TIERS, LIFESTYLE_OPTIONS, canonicalLifestyleTier, canonicalLifestyleOption, lifestyleOptionAllowed, lifestyleTierFor } from './utilities/commerce.js';
@@ -590,6 +593,19 @@ export default class Game {
         // `?? []`: hosted-homecoming.test.ts drives a Game off its prototype,
         // where field initialisers never ran.
         for (const le of this._looseEnds ?? []) {
+            // A HIRED SCRUB RESOLVES BEFORE THE DESK DOES (cleanup-errand.ts).
+            // You paid at the hub and did not get to watch; this is where the
+            // decker reports back, and it happens whatever grace is left --
+            // that is what the nuyen bought.
+            if (le.hired) {
+                const done = this.settleHiredCleanup(le);
+                lines.push(...done.lines);
+                // A botched scrub leaves the footage exactly where it was, and
+                // the grace clock keeps running -- you bought an attempt.
+                if (done.keep)
+                    kept.push(done.record);
+                continue;
+            }
             const left = le.homecomingsLeft - 1;
             if (left > 0) {
                 kept.push({ ...le, homecomingsLeft: left });
@@ -607,6 +623,60 @@ export default class Game {
         }
         return lines;
     }
+    /**
+     * A HIRED SCRUB REPORTS BACK (utilities/cleanup-errand.ts). The
+     * decker's test is rolled HERE, not at hire time: you paid for a
+     * result you do not get to watch, and the delay is the point.
+     *
+     * The pool was banked on the record at hire (the fixer's Connection +
+     * Loyalty) so a loyalty shift in between cannot retroactively change a
+     * job already bought. It rolls against the host's rating -- the same
+     * ice the runner would have had to get through.
+     */
+    settleHiredCleanup(le) {
+        const hired = le.hired;
+        const mine = rollPool(Math.max(1, hired.pool));
+        const host = rollPool(Math.max(1, le.host.rating));
+        const outcome = cleanupOutcome(mine.hits - host.hits, mine.criticalGlitch);
+        Logger.getInstance().write(`Cleanup errand "${le.id}": ${hired.decker} via ${hired.fixer}, ${mine.hits} v ${host.hits} -> ${outcome}.`);
+        Logger.getInstance().meta(`Cleanup errand -- ${hired.decker} (${hired.fixer}'s reach): ${formatRoll(mine)} v. ${le.site}'s host: ${formatRoll(host)}`);
+        if (outcome === 'botched') {
+            // The clock keeps running, and the hire is spent: the record goes
+            // back to being yours to deal with.
+            const left = le.homecomingsLeft - 1;
+            const stillOpen = left > 0;
+            if (!stillOpen) {
+                const stained = this.player.addPublicAwareness(`caught on the cameras at "${le.site}" during "${le.jobName}"`);
+                return {
+                    lines: [`\n{red-fg}${hired.fixer} calls, short: "${hired.decker} got burned off ${le.site}'s host. Didn't get it." And then the desk reviews the feeds anyway.{/red-fg}${stained ? ` (+1 Public Awareness, now ${this.player.publicAwareness})` : ''}`],
+                    keep: false,
+                    record: le,
+                };
+            }
+            return {
+                lines: [`\n{yellow-fg}${hired.fixer} calls, short: "${hired.decker} got burned off ${le.site}'s host. Didn't get it -- and no, you don't get the nuyen back."{/yellow-fg}${hint(` (The footage is still up. Hire again, or "jack in" and "hop ${le.site}" yourself.)`)}`],
+                keep: true,
+                record: { ...le, homecomingsLeft: left, hired: undefined },
+            };
+        }
+        const leverage = outcome === 'leverage';
+        return {
+            lines: [`\n{light-blue-fg}${hired.fixer} pings you two days on: "${le.site}'s feeds from '${le.jobName}' are a loop of an empty hallway. You were never there."{/light-blue-fg}${leverage ? `\n{yellow-fg}A beat later, a second message from a number you don't know: a single still of your face, and nothing else. ${hired.decker} kept a copy.{/yellow-fg}` : ''}`],
+            keep: false,
+            record: le,
+        };
+    }
+    /**
+     * HIRE A SHADOW DECKER for an open loose end (commands/crew.ts,
+     * "hire cleanup"). Debits the nuyen and stamps the record; the job
+     * itself resolves at the next homecoming (settleHiredCleanup).
+     */
+    hireCleanup(le, hired) {
+        const idx = this._looseEnds.findIndex(x => x.id === le.id);
+        if (idx >= 0)
+            this._looseEnds[idx] = { ...this._looseEnds[idx], hired };
+        Logger.getInstance().write(`Cleanup hired: ${hired.decker} via ${hired.fixer} for "${le.id}" at ${hired.price} nuyen.`);
+    }
     /** The grids "hop" lists for the open loose ends -- from the hub only. */
     looseEndGrids() {
         if (!this.hasHub || this.scene !== this._hubScene)
@@ -823,6 +893,17 @@ export default class Game {
     holdsLiveSeat() {
         return this.ridingWith.length > 0 || this.crew.some(m => m.ghost?.liveOnly);
     }
+    /** Everything the presence gate judges on, in one place -- so no
+     *  caller can answer half of it for itself (TLKZKLQ4rJBCnDjrw). */
+    presenceFacts() {
+        return {
+            anonymous: this._anonymous,
+            bench: this._bench,
+            hostedHub: this._hostedHub,
+            atHub: this.scene === this._hubScene,
+            holdsLiveSeat: this.holdsLiveSeat(),
+        };
+    }
     beatPresence() {
         if (!this.hasHub)
             return;
@@ -841,8 +922,11 @@ export default class Game {
         // reports, both sides of one table, twice in ten minutes.
         //
         // The rule itself lives in utilities/presence-gate.ts so it can be
-        // tested without a Game, a hub, or a socket.
-        if (!presenceBeatAllowed(this.scene === this._hubScene, this.holdsLiveSeat()))
+        // tested without a Game, a hub, or a socket -- and it is the WHOLE
+        // rule, account half included. `returnToHub` calls this method
+        // directly at every homecoming, so a gate that only guarded the
+        // timer-arming path was no gate at all (TLKZKLQ4rJBCnDjrw).
+        if (!presenceBeatAllowed(this.presenceFacts()))
             return;
         void heartbeatPresence(this.presencePayload());
         // The hub link rides the same pulse: a failed connect at boot must
@@ -861,14 +945,18 @@ export default class Game {
      */
     async pushPresenceNow() {
         // A hosted hub never dials the site from inside the site: the box's
-        // own `maka login`, if any, is not this player's.
-        if (this._anonymous || this._bench || this._hostedHub)
+        // own `maka login`, if any, is not this player's. Same predicate the
+        // heartbeat uses -- one account rule, one place.
+        if (!presenceProcessOnTheStreet(this.presenceFacts()))
             return 'offline';
         return heartbeatPresenceNow(this.presencePayload());
     }
     startPresenceHeartbeat() {
-        if (this._anonymous || this._bench || this._hostedHub)
-            return; // account-less, a bench, or hosted on the site: never on the street
+        // Account-less, a bench, or hosted on the site: never on the street,
+        // so don't even arm the timer. beatPresence checks this again -- it
+        // has to, because returnToHub beats without ever coming through here.
+        if (!presenceProcessOnTheStreet(this.presenceFacts()))
+            return;
         if (this._presenceTimer)
             return;
         this.beatPresence();
@@ -2983,6 +3071,12 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('wipe', EraseCommand);
         // MAtrix Recognition Keys (canon p.235-236).
         CommandFactory.registerCommand('mark', MarkCommand);
+        CommandFactory.registerCommand('unmark', EraseMarkCommand);
+        // SPRITE POWERS (p.256-257): one verb per power, reached as
+        // "order <sprite> <power> <target>" -- see commands/sprite-power.ts.
+        for (const [key, cls] of Object.entries(SPRITE_POWER_COMMANDS)) {
+            CommandFactory.registerCommand(key, cls);
+        }
         // Camera feeds you own (surveillance).
         CommandFactory.registerCommand('snoop', SnoopCommand);
         // The cable into a slaved camera (canon p.232/233) -- "splice" is
@@ -3365,8 +3459,20 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             const where = this._resumedAt && this._resumedAt !== this._homeRoom
                 ? `You're back at the ${this._resumedAt.name}${this.player.atSpot ? `, by the ${this.player.atSpot}` : ''} -- right where you left off.`
                 : 'The cot remembers your shape.';
+            // THE NAG HAS TO NAME A ROUTE THIS RUNNER CAN TAKE (user
+            // 2026-09-15). "jack in, then hop" is closed to anyone without a
+            // deck and a direct neural interface -- which is most runners --
+            // so a street samurai was told about a consequence and handed no
+            // lever. The errand (utilities/cleanup-errand.ts) is that lever,
+            // and it is the advice a non-decker gets.
+            const hiredNote = this._looseEnds.some(le => le.hired)
+                ? ` Somebody is already on one of them.`
+                : '';
+            const route = this.player.canReachMatrix()
+                ? `"jack in", then "hop" -- the site's grid is listed while the footage is still up there. Or "ask <contact> about cleanup" to buy the scrub instead.`
+                : `"ask <contact> about cleanup" -- you can't ride the grid, but somebody you know knows somebody who can.`;
             const looseNote = this._looseEnds.length > 0
-                ? `\n\n{yellow-fg}${this._looseEnds.map(le => `${le.site} still has your face from "${le.jobName}".`).join(' ')}{/yellow-fg}${hint(` ("jack in", then "hop" -- the site's grid is listed while the footage is still up there.)`)}`
+                ? `\n\n{yellow-fg}${this._looseEnds.map(le => `${le.site} still has your face from "${le.jobName}".`).join(' ')}${hiredNote}{/yellow-fg}${hint(` (${route})`)}`
                 : '';
             return `Welcome back, ${this.player.name}. ${where}\n ${this.scene.story}${pendingNote}${looseNote}`;
         }
@@ -6629,7 +6735,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // players" / "crew street"); the bare verb still answers quietly.
         { title: 'party', entries: [['crew', 'party'], ['hire'], ['dismiss'], ['train'], ['order'], ['lead'], ['command'], ['deploy'], ['recall'], ['stow']] },
         { title: 'magic', entries: [['spells'], ['cast'], ['summon', 'conjure'], ['project', 'astral'], ['return'], ['assense'], ['counterspell']] },
-        { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['mark'], ['disable'], ['brick'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['hide'], ['edit'], ['erase', 'wipe'], ['pan'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
+        { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['mark'], ['unmark'], ['disable'], ['brick'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['hide'], ['edit'], ['erase', 'wipe'], ['pan'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
         // The Emerged get their own shelf (player request: "there MUST be
         // resonance" -- matrix is the place, Resonance is the talent).
         // `sustain` shelves here and not under magic: the command is

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

@@ -77,6 +77,14 @@ export class Host {
     /** Kinds crashed this turn; the host relaunches them next turn (p.355-356). */
     relaunchQueue = [];
     patrolCountdown;
+    /**
+     * SUPPRESSION (SR5 p.257, utilities/sprite-power-actions.ts): a sprite
+     * inside the host is arguing with its launch paths, so IC it brings up
+     * arrives (Level / 2) Combat Turns late -- and "delayed IC can't act or
+     * be targeted" while it waits. Counted down by hostTurnStart. Session
+     * state, like the rest of the fight.
+     */
+    icLaunchDelay = 0;
     /** A haven (jackpoint.ts): never hunts, shows no rating, forgets cracks. */
     sanctioned = false;
     /**

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

@@ -49,6 +49,25 @@ export class Item extends AbstractItem {
     // work (rest.ts). A reboot does NOT clear it; that is the whole
     // difference from `jammed`.
     bricked = false;
+    /**
+     * SPRITE POWERS ON A FILE (SR5 p.256-257,
+     * utilities/sprite-power-actions.ts). Matrix-plane items only; all
+     * three are session state, like the marks and sightings they sit
+     * beside -- a sprite's work lasts as long as the sprite does.
+     *
+     * CAMOUFLAGE: folded inside another file, so a Matrix Search walks
+     * past it (commands/search.ts) and only a Matrix Perception hunting
+     * this file turns it up -- the sprite included.
+     */
+    concealedBy;
+    /** HASH: sealed by a Resonance algorithm only this sprite can undo, for
+     *  `hashTurns` Combat Turns. Nothing else edits or deletes it while it
+     *  holds (commands/edit-file.ts). */
+    hashedBy;
+    hashTurns = 0;
+    /** WATERMARK: an invisible tag only Resonance-driven things read -- a
+     *  technomancer or another sprite. A new one overwrites the old. */
+    watermark;
     _transferable;
     // New currency-related fields
     _currencyAmount = 0;

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

@@ -735,6 +735,14 @@ export class NPC extends Player {
     }
     boundDevice;
     companionKind;
+    /**
+     * ELECTRON STORM (SR5 p.257, utilities/sprite-power-actions.ts): the
+     * persona this sprite is holding a storm open on. It burns again every
+     * action the sprite spends sustaining it, and "if the sprite takes any
+     * Matrix damage, all of its electron storms end immediately" -- which
+     * is why this is cleared on damage rather than on a timer.
+     */
+    sustainedStorm;
     /**
      * Runs one command AS this NPC through its own scene-bound registry --
      * the deterministic control surface for "order <companion> <command>"