@maka/maka-cli 5.200.0 → 5.201.0

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

@@ -27,18 +27,28 @@
  * sprite type, and the five types' assignments account for all nine
  * exactly once -- the book's own list closes.
  *
- * WHAT THIS IS NOT. These are REFERENCE, not mechanics: no power below
- * is wired to a die roll in this engine yet, and `sprites.ts` says so
- * on the panel rather than implying otherwise. Listing an ability the
- * game cannot actually perform, without saying so, is the same defect
- * as a refusal naming a route that does not exist -- the game has paid
- * for that shape more than once. The listing answers "what is this
- * thing FOR", which is what was asked; it does not promise a verb.
+ * THIS TABLE IS NOW THE CATALOGUE BEHIND REAL VERBS (2026-09-15). It
+ * shipped as reference only -- "no power below is wired to a die roll in
+ * this engine yet", and sprites.ts said so on the panel rather than
+ * implying otherwise. Eight of the nine are moves you can type now:
+ * utilities/sprite-power-actions.ts resolves them, keyed off the same
+ * five sprite keys, so the panel and the mechanics cannot drift.
+ *
+ * STABILITY IS DELIBERATELY STILL REFERENCE, and `runnable` below is how
+ * each entry says which it is. Stability demotes glitches, and glitches
+ * are read at sixteen scattered sites in this engine (rest, climbing,
+ * haggling, barrier combat, hiring...). Wiring it at three of them would
+ * produce a power that works where someone happened to look and silently
+ * does nothing everywhere else -- which is exactly the "wrong ability on
+ * a sprite is worse than a missing one" case (CLAUDE.md). It wants the
+ * glitch contract changed in one place first, and that is its own piece
+ * of work.
  */
 /** All nine, alphabetical as the book lists them (p.256). */
 export const SPRITE_POWERS = [
     {
         key: 'camouflage',
+        runnable: true,
         name: 'Camouflage',
         effect: 'Hides a file inside another file, invisible to Matrix searches. Only a Matrix Perception Test specifically hunting the hidden file will turn it up -- and the sprite has to make that test too, to get its own file back out.',
         test: undefined,
@@ -46,6 +56,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'cookie',
+        runnable: true,
         name: 'Cookie',
         effect: 'Tags a persona with a silent tracking file rated at the sprite\'s Level. It logs every host entered, every program used, and who was talked to and when (not what was said). Net hits set the depth: one hit is a bare outline, four or more a detailed report. At a time set when it was placed the file ships itself back to the sprite -- and deletes itself instead if the sprite has left the Matrix. A Matrix Perception Test on the carrier finds it; unprotecting it and deleting it removes it.',
         test: 'Hacking + Resonance [Sleaze] v. Intuition + Firewall',
@@ -53,6 +64,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'diagnostics',
+        runnable: true,
         name: 'Diagnostics',
         effect: 'Reads a device down to its seams and helps somebody use or repair it, as a Teamwork Test. Any hits give +1 limit, and each hit adds a die to their pool. It takes the sprite\'s whole attention -- the bonus lasts until it drops the power or does anything else.',
         test: 'Simple Hardware + Level [Data Processing]',
@@ -60,6 +72,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'electron-storm',
+        runnable: true,
         name: 'Electron Storm',
         effect: 'Engulfs a persona in a sustained barrage of corrupting datastreams. On the first hit and on every action the sprite spends sustaining it, the target takes (Resonance) DV Matrix damage, resisted as normal, plus 2 points of noise. If the sprite takes any Matrix damage of its own, every storm it is sustaining ends at once.',
         test: 'Cybercombat + Resonance [Attack] v. Intuition + Firewall',
@@ -67,6 +80,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'gremlins',
+        runnable: true,
         name: 'Gremlins',
         effect: 'Makes a device misbehave -- a jammed control, a looped signal, a faulty reading. Success is a glitch; four or more net hits is a critical one, and the device crashes, burns out, or bites its user.',
         test: 'Hardware + Level [Attack] v. Device Rating + Firewall',
@@ -74,6 +88,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'hash',
+        runnable: true,
         name: 'Hash',
         effect: 'Seals a file with a Resonance algorithm only that sprite can undo, for up to (Level x 10) Combat Turns. Put the file down and it reverts to normal. Destroy the sprite while it still carries the file and the file is corrupted for good.',
         test: undefined,
@@ -81,6 +96,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'stability',
+        runnable: false,
         name: 'Stability',
         effect: 'Steadies any persona or device the sprite holds a mark on: standard glitches are ignored outright and critical glitches drop to standard. It stops induced accidents too, Gremlins included -- which is why a machine sprite can both cause and prevent them.',
         test: undefined,
@@ -88,6 +104,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'suppression',
+        runnable: true,
         name: 'Suppression',
         effect: 'Baffles a host into hesitating. A sprite using this inside a host delays any IC it launches by (Level / 2) Combat Turns, and delayed IC can neither act nor be targeted.',
         test: undefined,
@@ -95,6 +112,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'watermark',
+        runnable: true,
         name: 'Watermark',
         effect: 'Marks an icon invisibly, readable only by Resonance-driven things -- a way to leave messages on Matrix objects that nobody else can see. A new watermark overwrites an old one, and it lasts as long as the icon does unless somebody erases the Matrix signature.',
         test: undefined,
@@ -108,6 +126,29 @@ export const SPRITE_POWER_SETS = [
     { spriteKey: 'fault', powers: ['electron-storm'], skills: ['Computer', 'Cybercombat', 'Hacking'], page: 'p.259' },
     { spriteKey: 'machine', powers: ['diagnostics', 'gremlins', 'stability'], skills: ['Computer', 'Electronic Warfare', 'Hardware'], page: 'p.259' },
 ];
+const MATRIX_BY_TYPE = {
+    data: l => ({ attack: l - 1, sleaze: l, dataProcessing: l + 4, firewall: l + 1 }),
+    fault: l => ({ attack: l + 3, sleaze: l, dataProcessing: l + 1, firewall: l + 2 }),
+    machine: l => ({ attack: l + 1, sleaze: l, dataProcessing: l + 3, firewall: l + 2 }),
+    crack: l => ({ attack: l, sleaze: l + 3, dataProcessing: l + 2, firewall: l + 1 }),
+    courier: l => ({ attack: l, sleaze: l + 3, dataProcessing: l + 1, firewall: l + 2 }),
+};
+export function spriteMatrix(spriteKey, level) {
+    const l = Math.max(1, level);
+    const build = MATRIX_BY_TYPE[spriteKey] ?? MATRIX_BY_TYPE.courier;
+    const attrs = build(l);
+    return {
+        attack: Math.max(0, attrs.attack),
+        sleaze: Math.max(0, attrs.sleaze),
+        dataProcessing: Math.max(0, attrs.dataProcessing),
+        firewall: Math.max(0, attrs.firewall),
+        resonance: l,
+    };
+}
+/** A sprite's Matrix condition monitor: 8 + (Level / 2) boxes (p.254). */
+export function spriteMatrixBoxes(level) {
+    return 8 + Math.floor(Math.max(1, level) / 2);
+}
 /** One power by key. */
 export function spritePower(key) {
     return SPRITE_POWERS.find(p => p.key === key);

package/bundle/typescript/src/commands/game/sideQuest/utilities/cleanup-errand.js

@@ -0,0 +1,67 @@
+/**
+ * PAYING SOMEBODY ELSE TO SCRUB THE FOOTAGE (user 2026-09-15: "I'd like
+ * 'cleanup' jobs to allow hiring a crew. This is for situations where the
+ * runner (say, Jynx -- street samurai) cannot access the matrix").
+ *
+ * THE HOLE THIS FILLS. A run that ends with live cameras leaves an
+ * ILooseEnd, and the hub nags about it every homecoming -- "Doc Wu's
+ * Clinic still has your face from 'Ash and Ledger'" -- while the only
+ * route it advertises is closed to most runners. `hop` needs a persona
+ * (commands/hop.ts), `jack in` needs a cyberdeck AND a direct neural
+ * interface (commands/jack.ts), and the cleanup scene is deliberately
+ * crew-free: "NO CLIENT, NO PAYOUT, NO NPCS" (factories/cleanup-seed.ts).
+ * So a street samurai was handed a consequence with no lever, and a
+ * +1 Public Awareness on a timer.
+ *
+ * WHY AN ERRAND AND NOT A CREW SEAT. The playable scene stays exactly as
+ * it is. Hiring a shadow decker through a fixer is the SR5 idiom, it
+ * respects the no-payout design (you PAY here -- there is no client to
+ * bill), and it does not need enterCleanup un-wired from the player or
+ * a crew member taught to cross into a Matrix scene. What it costs is
+ * nuyen and a little control: you are not there, so you do not get to
+ * roll for it.
+ *
+ * IT RIDES THE LOOSE END ITSELF (ILooseEnd.hired), which is already on
+ * the save -- so a hired errand survives a reload with no new save field
+ * and no SAVE_VERSION bump, and settleLooseEnds resolves it at the next
+ * homecoming like everything else on that record.
+ */
+/** What a scrub costs before haggling. */
+export function cleanupQuote(le) {
+    // A harder host is a harder job: the decker has to get through the same
+    // ice the runner would have. Rooms are how much footage there is to
+    // find. Round to something a fixer would actually say out loud.
+    const base = 1500 + (le.host.rating * 400) + (Math.max(1, le.rooms.length) * 250);
+    return Math.round(base / 100) * 100;
+}
+/**
+ * The decker's own test, rolled at the HOMECOMING rather than at hire
+ * time -- you paid for a result you do not get to watch.
+ *
+ * The pool is the fixer's reach (Connection) plus how much they care
+ * (Loyalty): a well-connected fixer knows a better decker, and one who
+ * likes you sends them sober. Against the host's rating, which is what
+ * the decker has to beat.
+ *
+ * LEVERAGE IS NOT A FAILURE. The file is gone either way; the difference
+ * is that somebody else now has a copy, which is a hook rather than a
+ * penalty -- the shadows run on favours owed.
+ */
+export function cleanupOutcome(netHits, criticalGlitch) {
+    if (criticalGlitch)
+        return 'botched';
+    if (netHits <= 0)
+        return 'botched';
+    return netHits >= 3 ? 'clean' : 'leverage';
+}
+/** The names a fixer's shadow decker answers to. Flavour, not mechanics. */
+export const SHADOW_DECKERS = ['Static', 'Nyx', 'Palimpsest', 'Ghostwrite', 'Null', 'Sundog'];
+export function pickShadowDecker(le) {
+    // Deterministic off the record's own id, so the quote and the job name
+    // the same person -- a fixer who offers "Static" does not send "Nyx".
+    let h = 0;
+    for (const ch of le.id)
+        h = (h * 31 + ch.charCodeAt(0)) >>> 0;
+    return SHADOW_DECKERS[h % SHADOW_DECKERS.length];
+}
+//# sourceMappingURL=cleanup-errand.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/cleanup-hire.js

@@ -0,0 +1,113 @@
+import { rollPool, formatRoll } from './dice.js';
+import { fuzzyPickName } from './fuzzy-match.js';
+import { cleanupQuote, pickShadowDecker } from './cleanup-errand.js';
+import { hint } from './hints.js';
+/**
+ * "ask <fixer> about cleanup" and "hire cleanup [<site>]" -- the two
+ * halves of paying somebody else to scrub your footage. The rules and
+ * pricing live in cleanup-errand.ts; this is the player-facing surface,
+ * kept out of both crew.ts and ask.ts because it belongs to neither.
+ */
+/** The best-placed contact to broker it: reach first, then how much they
+ *  like you. A fixer with no reach knows no deckers. */
+function brokerFor(game) {
+    let best;
+    for (const [name, c] of game.contacts.entries()) {
+        const score = c.connection * 2 + c.loyalty;
+        const bestScore = best ? best.connection * 2 + best.loyalty : -1;
+        if (score > bestScore)
+            best = { name, connection: c.connection, loyalty: c.loyalty };
+    }
+    return best;
+}
+/** The open loose end this request means -- named, or the freshest. */
+function pickLooseEnd(game, query) {
+    const open = game.looseEnds.filter(le => !le.hired);
+    if (open.length === 0)
+        return undefined;
+    if (!query)
+        return open[open.length - 1];
+    const picked = fuzzyPickName(query, open.map(le => le.site));
+    return picked ? open.find(le => le.site === picked) : undefined;
+}
+/**
+ * THE QUOTE (reached from "ask <contact> about cleanup"). No dice, no
+ * commitment, and no per-homecoming budget spent: this is a price, not
+ * legwork.
+ */
+export function cleanupQuoteFor(game, contactName, query = '') {
+    const le = pickLooseEnd(game, query);
+    if (!le) {
+        return game.looseEnds.length > 0
+            ? `"Already got someone on that one," ${contactName} says. "Sit tight."`
+            : `"Nothing of yours is sitting on anybody's host right now," ${contactName} says. "Enjoy it."`;
+    }
+    const contact = game.contacts.get(contactName);
+    if (!contact)
+        return undefined;
+    const decker = pickShadowDecker(le);
+    const price = cleanupQuote(le);
+    return [
+        `"${le.site}?" ${contactName} thinks about it. "Got a kid calls themselves ${decker} who scrubs feeds. `,
+        `Rating ${le.host.rating} host, ${le.rooms.length} room${le.rooms.length === 1 ? '' : 's'} of it -- ${price} nuyen and your face was never there."`,
+        hint(` ("hire cleanup${game.looseEnds.filter(l => !l.hired).length > 1 ? ` ${le.site}` : ''}" to send them in. Negotiation trims the price; the job lands when you next come home.)`),
+    ].join('');
+}
+/** THE HIRE: haggle, debit, stamp the record. The job itself resolves at
+ *  the next homecoming (Game.settleHiredCleanup). */
+export function hireCleanupErrand(actor, game, query, logger) {
+    const le = pickLooseEnd(game, query);
+    if (!le) {
+        const hiredAlready = game.looseEnds.some(le2 => le2.hired);
+        if (hiredAlready)
+            return `That one's already bought and paid for -- it lands when you next come home.`;
+        if (query)
+            return `Nothing of yours is sitting on a host called "${query}".`;
+        return `Nothing of yours is on anybody's host right now.${hint(` (A run that ends with the cameras still live leaves footage behind -- that is what this buys off.)`)}`;
+    }
+    const broker = brokerFor(game);
+    if (!broker) {
+        return `You don't know anybody who knows a decker.${hint(` (Contacts broker this -- trade with people, run their errands. "contacts" shows who talks to you.)`)}`;
+    }
+    const asking = cleanupQuote(le);
+    const decker = pickShadowDecker(le);
+    // ONE NEGOTIATION PASS, the same fence-counter school "hire" uses on a
+    // crew cut -- against the fixer's own Charisma-ish reach.
+    const negotiation = actor.skillRating('negotiation');
+    const mine = rollPool(Math.max(1, actor.charisma + (negotiation > 0 ? negotiation : -1)
+        + actor.socialRep + actor.bonus('social') + actor.woundModifier - actor.sustainingPenalty));
+    const theirs = rollPool(Math.max(1, broker.connection + 2));
+    const net = mine.hits - theirs.hits;
+    // A critical glitch talks the price UP -- you argued badly and they
+    // remembered it (the shape haggle.ts and hire already use).
+    const price = mine.criticalGlitch
+        ? Math.round(asking * 1.2 / 100) * 100
+        : Math.max(Math.round(asking * 0.6 / 100) * 100, asking - Math.max(0, net) * 200);
+    logger.meta(`Cleanup terms -- you (Cha + Negotiation): ${formatRoll(mine)}`);
+    logger.meta(`  ${broker.name} (Connection ${broker.connection}): ${formatRoll(theirs)} -- ${price} nuyen (asked ${asking})`);
+    if (actor.currency < price) {
+        return `${broker.name} names ${price} nuyen for ${le.site}. You're carrying ${actor.currency}.${hint(` (Nobody scrubs a host on credit.)`)}`;
+    }
+    actor.adjustCurrency(-price);
+    game.hireCleanup(le, {
+        fixer: broker.name,
+        price,
+        decker,
+        // Banked now so a loyalty shift before the homecoming cannot
+        // retroactively change a job already bought.
+        pool: broker.connection + broker.loyalty,
+    });
+    actor.performAction('hires a scrub', `${decker} on ${le.site}'s feeds`);
+    game.requestSave?.('cleanup');
+    const haggled = price < asking
+        ? `talked down from ${asking}`
+        : price > asking
+            ? `talked UP from ${asking} -- they didn't like your tone`
+            : `at the asking price`;
+    return [
+        `{light-blue-fg}${broker.name} makes one call and hangs up. "${decker}'s on it."{/light-blue-fg}`,
+        `\nYou slide ${price} nuyen across (${haggled}). ${actor.currency} left.`,
+        hint(` (Nothing to watch -- you're not the one going in. ${decker} reports back when you next come home from a job.)`),
+    ].join('');
+}
+//# sourceMappingURL=cleanup-hire.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/drone-prose.js

@@ -246,7 +246,15 @@ export function droneReconNowhereLine(item) {
         missile: `The ${item.name} climbs, circles once -- nowhere to go from here.`,
     });
 }
-export function droneReconLaunchLine(item, rollText, ok) {
+/**
+ * THE PROSE NO LONGER CARRIES THE DICE (wjFBY3zgyWzJP9adw sweep). This
+ * baked `Piloting: 8d6 -> 2 hits` into the world log while every other
+ * player test in the engine sends its anatomy to the Mechanics panel --
+ * the recon sweep was the one roll a rigger had to read out of a
+ * sentence. `rollText` is gone; commands/drone.ts emits the roll through
+ * logger.meta, and this line goes back to being prose.
+ */
+export function droneReconLaunchLine(item, ok) {
     const off = pick(item, {
         'flier-palm': `The ${item.name} whirs off your palm`,
         flier: `The ${item.name} lifts off your hand`,
@@ -256,7 +264,7 @@ export function droneReconLaunchLine(item, rollText, ok) {
         missile: `The ${item.name} kicks off its rail`,
     });
     if (!ok)
-        return `${off} -- Piloting: ${rollText}`;
+        return off;
     const threads = pick(item, {
         'flier-palm': 'threads the gaps',
         flier: 'threads the gaps',
@@ -265,7 +273,7 @@ export function droneReconLaunchLine(item, rollText, ok) {
         anthro: 'goes to look',
         missile: 'makes a fast pass',
     });
-    return `${off} and ${threads} -- Piloting: ${rollText}. Feed incoming:`;
+    return `${off} and ${threads}. Feed incoming:`;
 }
 export function droneReconReturnLine(item) {
     return pick(item, {

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

@@ -77,6 +77,48 @@ export function hostLabel(room, opts = {}) {
     const bare = room.name.replace(/^the\s+/i, '');
     return `${opts.capital ? 'The' : 'the'} ${bare} host`;
 }
+/**
+ * WHAT THE HOST RUNS ON, ONCE YOU HAVE PAID FOR IT (np6YBSPsdfAY7NcuZ,
+ * Maka: "data like this ... shouldn't be visible without a matrix search
+ * on the host").
+ *
+ * `Host.purpose` is seed content and the generator is told to fill it
+ * with "what this place runs on its host and so what is worth protecting
+ * inside it" (factories/scene-chunks.ts) -- so in practice it enumerates
+ * the archive: "patient intake logs, med supply orders, and the doc's
+ * private black book of who paid what for what". Four renderers printed
+ * that on the host's OUTSIDE icon with no roll, which handed a passer-by
+ * the inventory of a sealed host for free. The file NAMES were already
+ * gated (grid-view.ts, Host.searchedBy); only this phrase leaked.
+ *
+ * TWO TIERS, and both are rolls the engine already makes
+ * (commands/search.ts matrixSearch):
+ *
+ *   tier 1  Room.searchedBy -- the threshold-1 public row out on the
+ *           grid (MATRIX_SEARCH.public). What the place runs on its host
+ *           is the kind of thing a public search turns up: canon has the
+ *           icon look like the shop (p.219). This set is also flipped by
+ *           a MEAT search of the room, and that is intended -- casing the
+ *           clinic in the flesh is a fair way to learn it keeps a ledger.
+ *   tier 2  Host.searchedBy -- the threshold-3 archive search from
+ *           inside, which additionally NAMES the files (grid-view.ts).
+ *
+ * A cracked host spills it free, exactly as its files already do: the
+ * seal is broken, there is nothing left to hide behind.
+ *
+ * Returns undefined when the seed declared no purpose OR the persona has
+ * not earned it, so every caller can `??` it away.
+ */
+export function hostPurposeFor(room, actor) {
+    const host = room.host;
+    if (!host?.purpose)
+        return undefined;
+    if (host.cracked)
+        return host.purpose;
+    return host.searchedBy.has(actor.name) || room.searchedBy.has(actor.name)
+        ? host.purpose
+        : undefined;
+}
 export function hostNameHint(room) {
     return room.hasNode ? `the host here answers to "host" or "${room.name}"` : '';
 }

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

@@ -1,5 +1,5 @@
 import { hostConcealedFrom } from './jackpoint.js';
-import { matchesHostName, hostLabel, hostAliases } from './grid-names.js';
+import { matchesHostName, hostLabel, hostAliases, hostPurposeFor } from './grid-names.js';
 import { fuzzyPickName, normalizeLoose } from './fuzzy-match.js';
 import { MAX_MARKS } from './marks.js';
 /**
@@ -193,10 +193,15 @@ export function hostLine(room, actor) {
     // A haven shows no rating and no eyes (jackpoint.ts): it is not a
     // thing you crack, so the numbers you would crack it with stay off.
     const rating = room.hostSanctioned ? '' : ` [HR ${room.hostRating}]`;
-    // The host's business, where the seed declared one (Host.purpose): a
-    // grid map that tells a clinic's records from a club's door list is
-    // the map that lets a runner pick a target.
-    const purpose = room.host?.purpose ? ` (${room.host.purpose})` : '';
+    // The host's business, where the seed declared one AND this persona has
+    // searched for it (hostPurposeFor, np6YBSPsdfAY7NcuZ). A grid map that
+    // tells a clinic's records from a club's door list is the map that lets
+    // a runner pick a target -- but it is a Matrix Search that draws it,
+    // not a glance. Map rows stay terse when it is unearned: the verb is
+    // taught on the host's own icon (grid-view.ts gridIcons), not once per
+    // row of a map that may list a dozen.
+    const found = hostPurposeFor(room, actor);
+    const purpose = found ? ` (${found})` : '';
     return `${inside ? '▣' : '●'} ${hostLabel(room, { capital: true })}${rating}${purpose}${onGrid} -- ${standing}${alert}${over}${inside ? ' -- INSIDE' : ''}`;
 }
 /** The Map dock's one-line host: icon, name, rating, standing -- cut to the dock. */

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

@@ -2,7 +2,7 @@ import { sameHostSide } from '../models/player.js';
 import { personasInside } from './matrix-roster.js';
 import { hostsInReach, hostLine, roomsInReach, gridVicinity } from './grid-reach.js';
 import { NPC } from '../models/npc.js';
-import { hostLabel } from './grid-names.js';
+import { hostLabel, hostPurposeFor } from './grid-names.js';
 import { isLinked } from './comm-style.js';
 import { isWatched, camerasLive, canSnoopFeeds } from './surveillance.js';
 /**
@@ -65,10 +65,13 @@ export function gridIcons(scene, actor, room) {
         // books never gave it -- boilerplate describing the opposite of what
         // the place is. A member is standing in a room they belong to.
         const hr = ` {bold}[HR ${room.hostRating}]{/bold}`;
-        // WHAT IT IS FOR rides the outside icon too: a host's business is
-        // public knowledge -- "your local Stuffer Shack has a host icon"
-        // (p.219) and the icon looks like the shop. The inside stays sealed.
-        const purpose = room.host?.purpose ? ` (${room.host.purpose})` : '';
+        // WHAT IT IS FOR rides the outside icon -- but only once a Matrix
+        // Search has turned it up (hostPurposeFor, np6YBSPsdfAY7NcuZ). The
+        // icon looking like the shop (p.219) is the NAME, which this line
+        // always prints; the seed's purpose phrase is an inventory of the
+        // archive, and handing that over for free is the report.
+        const found = hostPurposeFor(room, actor);
+        const purpose = found ? ` (${found})` : '';
         if (room.hostSanctioned) {
             icons.push(`● ${hostLabel(room, { capital: true })} -- three spheres turning over rooms that were never sold to anyone. You're on the list; nothing here is hunting.`);
         }
@@ -82,7 +85,18 @@ export function gridIcons(scene, actor, room) {
             // anyone inside it are on the far side of a wall (p.246). The
             // marks line stays because a mark is the DOOR (p.239), so it is
             // the one fact about the inside that belongs on the outside.
-            icons.push(`● ${hostLabel(room, { capital: true })}${hr}${purpose} -- sculpted ice geometry, sealed. Whatever it holds is inside it.${room.hostAlert ? ' Walls UP -- it holds a mark on an intruder.' : ''}${myMarks > 0 ? ` [your marks: ${myMarks}/3]` : ''} (${myMarks > 0 ? '"enter" walks in on your mark; ' : ''}"hack" slips in on sleaze; "hack loud" smashes; "mark" softens it first)`);
+            // The verb that EARNS the purpose phrase is offered only while it
+            // is still unearned -- a host that has already told you its
+            // business has nothing left to sell. Built as a list so a dropped
+            // entry cannot leave a dangling separator.
+            const ways = [
+                ...(myMarks > 0 ? ['"enter" walks in on your mark'] : []),
+                '"hack" slips in on sleaze',
+                '"hack loud" smashes',
+                '"mark" softens it first',
+                ...(found ? [] : ['"search" reads what it runs (p.241)']),
+            ];
+            icons.push(`● ${hostLabel(room, { capital: true })}${hr}${purpose} -- sculpted ice geometry, sealed. Whatever it holds is inside it.${room.hostAlert ? ' Walls UP -- it holds a mark on an intruder.' : ''}${myMarks > 0 ? ` [your marks: ${myMarks}/3]` : ''} (${ways.join('; ')})`);
         }
     }
     // WHERE THE HOST'S OWN ICON ENDS AND THE STREET BEGINS.
@@ -457,7 +471,11 @@ export function gridSculpt(actor, room) {
         // sculpting is shown as that -- the purpose on the header, the
         // sculpt where the boilerplate used to stand. The boilerplate stays
         // for a hand-authored host that declared neither.
-        const purpose = room.host?.purpose;
+        // The purpose is still the searched-for fact in here (hostPurposeFor):
+        // standing inside a host is not the same as having read its index.
+        // The SCULPT is not gated -- it is the architecture around you, and
+        // you are looking at it.
+        const purpose = hostPurposeFor(room, actor);
         const sculpt = room.host?.sculpt;
         return [
             `{light-blue-fg}INSIDE :: ${hostLabel(room, { capital: true }).toUpperCase()} [HR ${room.hostRating}]${purpose ? ` -- ${purpose}` : ''}{/light-blue-fg}`,
@@ -559,8 +577,11 @@ export function hostInteriorPanel(scene, actor, host, rows, cols) {
     const cut = (raw) => `{light-blue-fg}${[...raw].slice(0, Math.max(4, cols)).join('')}{/light-blue-fg}`;
     const lines = [];
     lines.push(cut(`INSIDE ${host.name}`));
-    if (host.purpose)
-        lines.push(cut(host.purpose));
+    // Same gate as every other renderer (hostPurposeFor): the dock is a
+    // view, not a back door.
+    const purpose = hostPurposeFor(host.over, actor);
+    if (purpose)
+        lines.push(cut(purpose));
     const marks = host.marksBy.get(actor.name) ?? 0;
     lines.push(cut(host.sanctioned
         ? 'haven -- welcome here'
@@ -574,7 +595,13 @@ export function hostInteriorPanel(scene, actor, host, rows, cols) {
             continue;
         lines.push(cut(`◆ ${a.name}`));
     }
-    const files = host.files().length;
+    // THE COUNT IS PART OF THE ARCHIVE (np6YBSPsdfAY7NcuZ). The icon list
+    // above gates the file NAMES on a Matrix Search; this line quietly
+    // published how many there were regardless, which is most of what the
+    // roll was protecting -- "three files sealed" tells a runner whether
+    // the trip is worth it. Same gate, same set.
+    const indexed = host.cracked || host.searchedBy.has(actor.name);
+    const files = indexed ? host.files().length : 0;
     if (files > 0)
         lines.push(cut(`◇ ${files} file${files === 1 ? '' : 's'} ${host.cracked ? 'open' : 'sealed'}`));
     return lines.slice(0, Math.max(1, rows));

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

@@ -47,6 +47,18 @@ async function tell(enc, scene, turn) {
  */
 export async function hostTurnStart(scene, host, enc) {
     const out = empty();
+    // SUPPRESSION (p.257, sprite-power-actions.ts): a sprite arguing with
+    // the host's launch paths delays what it brings up by (Level / 2)
+    // Combat Turns, and "delayed IC can't act or be targeted" -- which is
+    // exactly "the launch step does not happen this turn". Counted down
+    // here so the delay is spent whether or not the host wanted to launch.
+    if (host.icLaunchDelay > 0) {
+        host.icLaunchDelay -= 1;
+        out.lines.push(`{light-blue-fg}Something in ${host.name}'s architecture is arguing with itself -- whatever it meant to bring up does not arrive.{/light-blue-fg}`);
+        seatRunningIce(enc, host);
+        await tell(enc, scene, out);
+        return;
+    }
     hostLaunchStep(host.over, scene, out);
     seatRunningIce(enc, host);
     await tell(enc, scene, out);

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

@@ -18,6 +18,16 @@ export function clearMarksPlacedBy(scene, placerName) {
     for (const room of Object.values(scene.getRooms())) {
         if (room.hostMarksBy.delete(placerName))
             cleared++;
+        // A DEVICE'S MARKS ARE MARKS (f79LLqTerep4nKWcA sweep). Device.marksBy
+        // is the third ledger -- hack.ts writes it for every slaved and loose
+        // icon -- and no wipe had ever touched it, so the maglock you keyed
+        // last run still answered to a persona canon says was deleted on
+        // reboot (p.236). It also meant `disable` could drive a device on
+        // marks the sheet no longer showed you holding.
+        for (const device of room.allDevices()) {
+            if (device.marksBy.delete(placerName))
+                cleared++;
+        }
     }
     for (const a of scene.allActors) {
         if (a.panMarksBy.delete(placerName))
@@ -71,6 +81,13 @@ export function describeMarks(scene, placerName) {
         const n = room.hostMarksBy.get(placerName) ?? 0;
         if (n > 0)
             lines.push(`● ${hostLabel(room, { capital: true })} -- ${n} mark${n === 1 ? '' : 's'}${n >= MAX_MARKS ? ' (it thinks you belong)' : ''}`);
+        // Devices too -- the ledger `disable` reads to drive a maglock was
+        // invisible on the listing that is supposed to show what you hold.
+        for (const device of room.allDevices()) {
+            const d = device.marksBy.get(placerName) ?? 0;
+            if (d > 0)
+                lines.push(`▲ ${device.name} -- ${d} mark${d === 1 ? '' : 's'}`);
+        }
     }
     for (const a of scene.allActors) {
         const n = a.panMarksBy.get(placerName) ?? 0;
@@ -92,6 +109,11 @@ export function marksPlaced(scene, placerName) {
         const n = room.hostMarksBy.get(placerName) ?? 0;
         if (n > 0)
             out.push({ target: hostLabel(room, { capital: true }), count: n });
+        for (const device of room.allDevices()) {
+            const d = device.marksBy.get(placerName) ?? 0;
+            if (d > 0)
+                out.push({ target: device.name, count: d });
+        }
     }
     for (const a of scene.allActors) {
         const n = a.panMarksBy.get(placerName) ?? 0;

package/bundle/typescript/src/commands/game/sideQuest/utilities/mechanics-audience.js

@@ -0,0 +1,71 @@
+/**
+ * WHO IS WATCHING THE DICE (wjFBY3zgyWzJP9adw, Deditri: "the sprite put a
+ * mark on the target but there was no output about the rolls in the
+ * logs").
+ *
+ * The sprite's dice WERE rolled. `order <sprite> mark <lock>` runs the
+ * real verb with the sprite as actor -- commands/order.ts hands the
+ * string to NPC.tryRunCommand, commands/mark.ts re-dispatches into
+ * HackCommand, and hack.ts rolls Hack on the Fly against the device
+ * exactly as it would for a decker. The roll was then thrown away at the
+ * REPORTING layer, by a guard that has been copied into ~30 commands:
+ *
+ *     if (this.scene.isHumanControlled(actor)) this.logger.meta(...)
+ *
+ * That asks "is the ROLLER a human". The question the Mechanics panel
+ * actually wants is "is a HUMAN WATCHING" -- and the codebase already
+ * answers it correctly two files over, in CombatExchange.playerWitnesses
+ * (utilities/combat-exchange.ts), which is precisely why a sprite's
+ * COMBAT rolls have always shown up while the same sprite's ordered
+ * mark went silent. One question, asked two ways, in one engine.
+ *
+ * WHY OWNERSHIP AND NOT PROXIMITY. playerWitnesses is a bystander test:
+ * same place, perceivable plane. That is right for a fight, which is an
+ * event in a room. It is wrong for an ORDER, which is a thing the player
+ * deliberately did: a rigger whose drone is sweeping the floor above,
+ * or a technomancer whose sprite is working a host their body is nowhere
+ * near, typed that command and is owed its dice. So a companion's rolls
+ * are shown to its master wherever it is standing. Anything that is
+ * NOT a companion -- IC, a guard, a passer-by -- keeps the old silence
+ * and reports through the channels it already had (utilities/ic.ts
+ * accumulates into IICTurn.meta; a fight goes through announce).
+ *
+ * THE FORK MUST STAY EXCLUSIVE. Several commands route the roll to
+ * EITHER the Mechanics panel (player) OR their own return string, which
+ * for an NPC is its AI history:
+ *
+ *     const isPlayer = scene.isHumanControlled(actor);
+ *     if (isPlayer) this.logger.meta(`Perception: ${formatRoll(roll)}`);
+ *     const rollPrefix = isPlayer ? '' : `Perception: ${formatRoll(roll)}\n`;
+ *
+ * Both halves must read the SAME predicate or an ordered companion
+ * prints its dice twice. Callers swapping to showsMechanics must swap
+ * both.
+ */
+/** The companion ledger entry for this actor, if it is somebody's. */
+function companionEntryFor(scene, actor) {
+    return scene.ownerGame?.companions?.find(c => c.npc === actor);
+}
+/**
+ * Should this actor's dice anatomy go to the Mechanics panel?
+ *
+ * True for a human-controlled actor (the old rule, unchanged), and for a
+ * companion a human is running -- a sprite, spirit, agent or drone whose
+ * master typed the order that got here.
+ */
+export function showsMechanics(scene, actor) {
+    if (scene.isHumanControlled?.(actor) === true)
+        return true;
+    return companionEntryFor(scene, actor) !== undefined;
+}
+/**
+ * The name to hang on a Mechanics line when the roller is not the player
+ * -- "Crack Sprite -- Hack on the Fly (sleaze) on Hatch Maglock: ...".
+ * Empty for the player's own rolls, which stay exactly as they read
+ * today: a panel that started prefixing the player's own name on every
+ * line would be noisier for the common case to serve the rare one.
+ */
+export function mechanicsActorPrefix(scene, actor) {
+    return scene.isHumanControlled?.(actor) === true ? '' : `${actor.name} -- `;
+}
+//# sourceMappingURL=mechanics-audience.js.map