@maka/maka-cli 5.182.0 → 5.184.0

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

@@ -379,7 +379,7 @@ export class LookCommand extends Command {
                 const dim = this.scene.getActorsInRoom(far)
                     .find(a => a !== this.actor && a.name.toLowerCase() === target.toLowerCase() && this.actor.canPerceive(a));
                 if (dim)
-                    return `${this.inspectPersona(dim)}\n{cyan-fg}  -- a far icon, ${far.name}${noiseNote(noise)}{/cyan-fg}`;
+                    return `${this.inspectPersona(dim)}\n{lightblue-fg}  -- a far icon, ${far.name}${noiseNote(noise)}{/lightblue-fg}`;
             }
         }
         // 3. THE HOST, as a thing you can name. gridIcons already renders it
@@ -396,8 +396,8 @@ export class LookCommand extends Command {
                 // `deck` reads out your own array.
                 const a = namedHost.hostAttributes();
                 return [
-                    `{cyan-fg}${hostIcon}{/cyan-fg}`,
-                    `{cyan-fg}  Attack ${a.attack}  Sleaze ${a.sleaze}  Data Processing ${a.dataProcessing}  Firewall ${a.firewall}{/cyan-fg}`,
+                    `{lightblue-fg}${hostIcon}{/lightblue-fg}`,
+                    `{lightblue-fg}  Attack ${a.attack}  Sleaze ${a.sleaze}  Data Processing ${a.dataProcessing}  Firewall ${a.firewall}{/lightblue-fg}`,
                 ].join('\n');
             }
         }
@@ -409,7 +409,7 @@ export class LookCommand extends Command {
         if (matchesCameraName(target)) {
             const eye = gridIcons(this.scene, this.actor, room).find(i => i.startsWith('◎'));
             if (eye)
-                return `{cyan-fg}${eye}{/cyan-fg}`;
+                return `{lightblue-fg}${eye}{/lightblue-fg}`;
             // Named correctly, and there is simply nothing here to name.
             // Worth its own line: the old answer said the WORDS were wrong,
             // which sent the player hunting for a synonym that never
@@ -525,7 +525,7 @@ export class LookCommand extends Command {
      * there's a deck anywhere in the shape of it.
      */
     inspectPersona(target) {
-        const lines = [`{cyan-fg}◆ ${target.name} -- a persona on this grid.{/cyan-fg}`];
+        const lines = [`{lightblue-fg}◆ ${target.name} -- a persona on this grid.{/lightblue-fg}`];
         const companion = this.scene.ownerGame?.companions.find(c => c.npc === target);
         if (companion) {
             lines.push(`Yours -- it goes where you go, and it answers when you speak.`);

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

@@ -93,7 +93,7 @@ export class MapCommand extends Command {
             actor.insideHost
                 ? `THE GRID -- INSIDE ${hostLabel(actor.insideHost, { capital: true }).toUpperCase()}`
                 : `THE GRID -- ${actor.currentGrid ? `on ${actor.currentGrid.name}, ` : ''}jacked in from ${body.name}`,
-            `{cyan-fg}Black flatland under a black sky. No streets out here -- only icons. The hosts hang overhead; ${actor.insideHost ? '"exit" puts you back under them' : '"go <host>" (or "go <number>") crosses into one you hold a mark on, from anywhere'}.{/cyan-fg}`,
+            `{lightblue-fg}Black flatland under a black sky. No streets out here -- only icons. The hosts hang overhead; ${actor.insideHost ? '"exit" puts you back under them' : '"go <host>" (or "go <number>") crosses into one you hold a mark on, from anywhere'}.{/lightblue-fg}`,
         ];
         if (hosts.length === 0) {
             lines.push('  Nothing overhead -- no host stands over this district.');

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

@@ -51,7 +51,7 @@ export class MarkCommand extends Command {
             screen: this.screen,
             game: this.game,
         }).execute(args);
-        return `{cyan-fg}Placing a mark IS ${action} -- running it (p.238/p.240).{/cyan-fg}\n${result}`;
+        return `{lightblue-fg}Placing a mark IS ${action} -- running it (p.238/p.240).{/lightblue-fg}\n${result}`;
     }
 }
 //# sourceMappingURL=mark.js.map

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

@@ -163,6 +163,19 @@ export class RestCommand extends Command {
             lines.push(`  Bench work on the ${deck.name}: ${formatRoll(repairRoll)}`);
             lines.push(`  ${repaired} box${repaired === 1 ? '' : 'es'} repaired: ${deck.deckSummary()}${wasBricked && !deck.isBricked ? ' -- it boots again.' : ''}`);
         }
+        // BRICKED GEAR (p.228 Repairing Matrix Damage): an hour with a
+        // toolkit and Hardware + Logic -- the rest is the hour, and every
+        // hit either clears boxes or halves the time, so by the end of a
+        // night's rest a bricked smartgun boots again. A reboot never does
+        // this; that is the difference between bricked and jammed.
+        const brickedGear = [
+            ...actor.inventory.getAllItems(),
+            actor.equipment.rightHand?.weapon, actor.equipment.leftHand?.weapon,
+        ].filter((i) => !!i && i.bricked);
+        for (const gear of new Set(brickedGear)) {
+            gear.bricked = false;
+            lines.push(`  Bench work on the ${gear.name}: the burnt boards come out, and it powers up again.`);
+        }
         for (const drone of damagedDrones) {
             const wasWrecked = drone.isWrecked;
             const repairRoll = rollPool(actor.logic + actor.skillRating('hardware') + actor.bonus('piloting'));

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

@@ -2,7 +2,9 @@ import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { planeTintItemName, emphasizeFind, objectiveMark, fileReach } from '../utilities/planes.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
-import { perceptionTest } from '../utilities/perception.js';
+import { perceptionTest, matrixSearchTest, matrixSearchSeconds, MATRIX_SEARCH } from '../utilities/perception.js';
+import { gridVicinity } from '../utilities/grid-reach.js';
+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';
@@ -135,6 +137,73 @@ ${coach}`;
 export class SearchCommand extends Command {
     static verb = 'search';
     static description = 'Search for items in your area';
+    /**
+     * MATRIX SEARCH (SR5 p.241, player ruling 2026-09-13: "a true matrix
+     * search, not perception, revealing what is inside a host if it's
+     * cracked open").
+     *
+     * A Special action: Computer + Intuition [Data Processing] against a
+     * threshold from the Matrix Search Table, and it takes TIME -- one
+     * minute inside a host whatever the information, net hits over the
+     * threshold dividing it, a miss spending it all, a Browse program
+     * halving it (utilities/perception.ts). The time is real: it moves
+     * the persona's Overwatch clock back, so a slow search inside a host
+     * is what GOD bills for (utilities/overwatch.ts billTime, +2d6 per
+     * 15 minutes).
+     *
+     * WHAT IT FINDS. Inside a host, the host's archive: from then on the
+     * interior lists its files for this persona (Host.searchedBy,
+     * grid-view.ts). A CRACKED host spills them without the roll -- the
+     * seal is broken, there is nothing to find. Out on the grid it is the
+     * public-knowledge row: the loose data icons in reach.
+     */
+    matrixSearch() {
+        const actor = this.actor;
+        const host = actor.hostInside;
+        const where = host ? host.over : gridVicinity(actor);
+        const row = host ? MATRIX_SEARCH.inHost : MATRIX_SEARCH.public;
+        const browse = actor.activeDeck?.hasProgram('browse') ?? false;
+        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`);
+        }
+        // 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
+        // seconds spent is what makes the next illegal action pay for them.
+        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');
+        const clock = `(${seconds}s of Matrix time${browse ? ', Browse cutting it' : ''})`;
+        if (roll.hits < row.threshold) {
+            return host
+                ? `You dig through ${hostLabel(where)}'s archive and the index keeps folding away from you -- nothing this pass. ${clock}${hint(` Try again; the host is not going anywhere.`)}`
+                : `You sweep ${where.name}'s grid for loose data and turn up nothing this pass. ${clock}`;
+        }
+        if (host) {
+            host.searchedBy.add(actor.name);
+            where.searchedBy.add(actor.name);
+            if (files.length === 0) {
+                return `The archive is indexed and EMPTY -- ${hostLabel(where)} keeps nothing worth the trip. ${clock}`;
+            }
+            const list = files.map(i => `${objectiveMark(this.scene, i.name)}${emphasizeFind(planeTintItemName(i, actor.plane))}`).join(', ');
+            const seal = where.hostCracked
+                ? hint(` ("take" them -- the seal is already broken.)`)
+                : hint(` (sealed in the host's data vault: "hack" the node to break the seal, then "take".)`);
+            return `The index gives up ${hostLabel(where)}'s archive: ${list}. ${clock}${seal}`;
+        }
+        where.searchedBy.add(actor.name);
+        const loose = where.hasNode ? [] : files;
+        if (loose.length === 0) {
+            const sealedElsewhere = files.length > 0 && where.hasNode;
+            return `Nothing loose on ${where.name}'s grid. ${clock}${sealedElsewhere ? hint(` (${hostLabel(where)} keeps its files INSIDE -- "enter" it and search from in there.)`) : ''}`;
+        }
+        const list = loose.map(i => `${objectiveMark(this.scene, i.name)}${emphasizeFind(planeTintItemName(i, actor.plane))}`).join(', ');
+        return `Loose on ${where.name}'s grid: ${list}. ${clock}${hint(` ("take" rides them out on your deck.)`)}`;
+    }
     async execute(_args) {
         const room = this.actor.currentLocation;
         // A MATRIX SEARCH IS MEASURED IN MINUTES (p.241: base time one
@@ -144,6 +213,8 @@ export class SearchCommand extends Command {
         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 or get out first.`;
         }
+        if (this.actor.plane === 'matrix')
+            return this.matrixSearch();
         // OBSERVE IN DETAIL (SR5 p.165): the Perception Test below is the
         // Simple Action the book names, inside a Combat Turn.
         const bill = billAction(this.scene, this.actor, 'simple', 'Observe in Detail');
@@ -155,17 +226,14 @@ export class SearchCommand extends Command {
         // room stays uncased ("take all" stays gated). Barriers (puzzles) are
         // in plain sight and show regardless -- you can't fail to notice the
         // maglock you're staring at.
-        // On the GRID a search is Matrix Search (canon: Computer, Logic) --
-        // best-of with perception so pre-computer deckers lose nothing.
-        // A loaded Browse program is purpose-built for Matrix Search: +2.
-        const browse = this.actor.plane === 'matrix' && this.actor.activeDeck?.hasProgram('browse') ? 2 : 0;
         // ACTIVE: this is the deliberate hunt, so it carries p.135-136's +3
         // for "perceiver is specifically looking for it" -- the modifier
         // that makes `search` mechanically different from `look` rather
         // than only differently named (FNgptvRhbA5yMunbB). The pool and the
         // bracket both live in utilities/perception.ts; look.ts rolls the
-        // same test without the +3.
-        const { pool, limit } = perceptionTest(this.actor, { active: true, browse });
+        // same test without the +3. The grid never comes through here: a
+        // persona's search is matrixSearch() above.
+        const { pool, limit } = perceptionTest(this.actor, { active: true });
         const roll = rollPool(pool, limit);
         // Roll anatomy to the Mechanics ticker for the player; an NPC's
         // return string is its AI history, so IT keeps the roll inline
@@ -234,28 +302,7 @@ export class SearchCommand extends Command {
         if (spotted.length > 0) {
             description += `\n{yellow-fg}You pick ${spotted.map(a => a.name).join(', ')} out of the shadows -- ${spotted.length === 1 ? 'they were' : 'they were'} there the whole time.{/yellow-fg}`;
         }
-        // Data is LOOT -- say so while the persona is standing on it, with the
-        // vault state attached: sealed files need the host cracked first. A
-        // real session's decker found the paydata jacked-in, didn't realize it
-        // was takeable from the grid, and went hunting for it in the meat.
-        if (this.actor.plane === 'matrix' && found.some(i => i.plane === 'matrix')) {
-            description += room.hasNode && !room.offlineServer && !room.hostCracked
-                ? `\n{cyan-fg}(the files sit sealed in the host's data vault -- "hack" the node to unseal them){/cyan-fg}`
-                : hint(`\n{cyan-fg}(data files are loot -- "take" them right here on the grid; they ride out on your deck){/cyan-fg}`);
-        }
-        // A persona sweeping the grid OUTSIDE a host: the files exist and
-        // this sweep cannot reach them. Say why, rather than reading empty
-        // -- a silent nothing is what made the old air-gap case feel broken.
-        if (this.actor.plane === 'matrix' && !filesInReach
-            && room.inventory.getAllItems().some(i => i.plane === 'matrix')) {
-            if (room.offlineServer) {
-                description += `\n{cyan-fg}There is a ${room.offlineServer} in this room and it is NOT on the Matrix -- nothing you can do from out here touches it.${hint(` Walk in and cable into it in the flesh.`)}{/cyan-fg}`;
-            }
-            else {
-                const marked = (room.hostMarksBy.get(this.actor.name) ?? 0) > 0 || room.hostCracked;
-                description += `\n{cyan-fg}This sweep only covers the open grid. Whatever the host holds is INSIDE it, behind its wall (p.246).${hint(marked ? ` "enter" and search again.` : ` A mark is the door -- "mark" the host, then "enter".`)}{/cyan-fg}`;
-            }
-        }
+        // The grid never reaches here: a persona's search is matrixSearch().
         // The mirror hint: a meat-side search can't see matrix files, but it
         // shouldn't pretend the room is empty when the good stuff is one
         // "jack in" away.
@@ -266,8 +313,8 @@ export class SearchCommand extends Command {
             // tells a player standing next to an offline server that it is
             // there and what it wants from them.
             description += room.offlineServer
-                ? `\n{cyan-fg}A ${room.offlineServer} sits here, dark and off the network -- no aerial, no marquee, nothing broadcasting. Whatever it holds comes out through a cable and no other way.${hint(` "jack in" RIGHT HERE to touch its files.`)}{/cyan-fg}`
-                : `\n{cyan-fg}The node here hums with locked files -- whatever's worth taking lives on the grid, inside the host.${hint(` "jack in", then "enter" the host.`)}{/cyan-fg}`;
+                ? `\n{lightblue-fg}A ${room.offlineServer} sits here, dark and off the network -- no aerial, no marquee, nothing broadcasting. Whatever it holds comes out through a cable and no other way.${hint(` "jack in" RIGHT HERE to touch its files.`)}{/lightblue-fg}`
+                : `\n{lightblue-fg}The node here hums with locked files -- whatever's worth taking lives on the grid, inside the host.${hint(` "jack in", then "enter" the host.`)}{/lightblue-fg}`;
         }
         description += describeContainers(room, this.actor);
         description += describeBarriers(room, this.actor);

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

@@ -49,7 +49,7 @@ export class SnoopCommand extends Command {
         this.logger.write(`Snoop: ${actor.name} watching ${target.name} via camera feed.`);
         const lines = [`CAMERA FEED: ${target.name.toUpperCase()}`];
         if (!camerasLive(allRooms, target)) {
-            lines.push(`{cyan-fg}(Security sees a loop of empty hallways -- these eyes answer only to you now.){/cyan-fg}`);
+            lines.push(`{lightblue-fg}(Security sees a loop of empty hallways -- these eyes answer only to you now.){/lightblue-fg}`);
         }
         const seen = this.scene.getActorsInRoom(target)
             .filter(a => a !== actor && a.plane === 'meat' && !a.sneaking);

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

@@ -73,7 +73,7 @@ export class SpritesCommand extends Command {
             const name = type?.name ?? set.spriteKey;
             const isMine = mineType === set.spriteKey;
             const powers = powersForSprite(set.spriteKey);
-            lines.push(`${name.toUpperCase()} SPRITE${isMine ? ' {cyan-fg}(yours){/cyan-fg}' : ''}${type ? ` -- ${type.blurb}` : ''}`);
+            lines.push(`${name.toUpperCase()} SPRITE${isMine ? ' {lightblue-fg}(yours){/lightblue-fg}' : ''}${type ? ` -- ${type.blurb}` : ''}`);
             lines.push(`  Skills: ${skillsForSprite(set.spriteKey).join(', ')}${hint(`  (${set.page})`)}`);
             if (!detailed) {
                 // The names alone, which is the comparison view.

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

@@ -158,9 +158,9 @@ export class TapCommand extends Command {
         }
         this.logger.write(`${actor.name} now holds ${now} mark(s) on ${host.name} via the ${room.name} cameras.`);
         const lines = [
-            `{cyan-fg}The filament finds the connector and the camera stops being a camera -- it's a device, and it's talking to you.{/cyan-fg}`,
-            `  {cyan-fg}It never gets to hide behind ${hostLabel(host)}: a cable doesn't ask the network for permission, so the lens has to defend itself with what a lens has. It doesn't have much.{/cyan-fg}`,
-            `  {cyan-fg}MARK PLACED -- and it lands on the host too. The camera answers to ${host.name}, and anything ${host.name} trusts to speak for it just handed you a key. [${now}/${MAX_MARKS}]{/cyan-fg}`,
+            `{lightblue-fg}The filament finds the connector and the camera stops being a camera -- it's a device, and it's talking to you.{/lightblue-fg}`,
+            `  {lightblue-fg}It never gets to hide behind ${hostLabel(host)}: a cable doesn't ask the network for permission, so the lens has to defend itself with what a lens has. It doesn't have much.{/lightblue-fg}`,
+            `  {lightblue-fg}MARK PLACED -- and it lands on the host too. The camera answers to ${host.name}, and anything ${host.name} trusts to speak for it just handed you a key. [${now}/${MAX_MARKS}]{/lightblue-fg}`,
         ];
         if (mode === 'attack') {
             lines.push(`  The housing is visibly forced -- the host FELT that one, even if nothing saw your face.`);
@@ -169,15 +169,15 @@ export class TapCommand extends Command {
             lines.push(`  Nothing logged, nothing flagged. You were never here.`);
         }
         if (host === room) {
-            lines.push(`  {cyan-fg}${now >= MAX_MARKS
+            lines.push(`  {lightblue-fg}${now >= MAX_MARKS
                 ? `The host thinks you belong now -- "hack" walks straight in.`
-                : `${hostLabel(host, { capital: true })} cracks easier with every key you hold${hint(` -- "jack in" and "hack", or come back for another lens`)}.`}{/cyan-fg}`);
+                : `${hostLabel(host, { capital: true })} cracks easier with every key you hold${hint(` -- "jack in" and "hack", or come back for another lens`)}.`}{/lightblue-fg}`);
         }
         else {
-            lines.push(`  {cyan-fg}These lenses ride the site network, so the key fits ${hostLabel(host)}${hint(` -- "jack in", "go ${host.name}", "hack"`)}.{/cyan-fg}`);
+            lines.push(`  {lightblue-fg}These lenses ride the site network, so the key fits ${hostLabel(host)}${hint(` -- "jack in", "go ${host.name}", "hack"`)}.{/lightblue-fg}`);
         }
         // A mark is all canSnoopFeeds ever wanted (surveillance.ts).
-        lines.push(`  {cyan-fg}And the eyes are half yours already${hint(` -- jacked in, "snoop <room>" rides any feed on this network`)}.{/cyan-fg}`);
+        lines.push(`  {lightblue-fg}And the eyes are half yours already${hint(` -- jacked in, "snoop <room>" rides any feed on this network`)}.{/lightblue-fg}`);
         lines.push(...godLines);
         this.scene.updateStatus();
         return lines.join('\n');

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

@@ -67,7 +67,7 @@ export class ThreadCommand extends Command {
             const lines = [`COMPLEX FORMS (thread <form> <level>)`];
             for (const f of FORMS) {
                 const held = actor.sustainedForms.some(s => s.key === f.key);
-                lines.push(`  ${f.name.padEnd(16)} ${f.kind === 'sustained' ? '[sustained]' : '[instant]  '} ${f.blurb}${held ? ' {cyan-fg}(HELD){/cyan-fg}' : ''}`);
+                lines.push(`  ${f.name.padEnd(16)} ${f.kind === 'sustained' ? '[sustained]' : '[instant]  '} ${f.blurb}${held ? ' {lightblue-fg}(HELD){/lightblue-fg}' : ''}`);
             }
             if (actor.sustainedForms.length > 0) {
                 lines.push('', `  Holding ${actor.sustainedForms.length} form${actor.sustainedForms.length === 1 ? '' : 's'} (${sustainTotal(actor.sustainedLedger().filter(w => w.kind === 'form'))}).${hint(` ("thread drop <form>" releases.)`)}`);

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

@@ -109,6 +109,7 @@ import { EndCallCommand } from './commands/end-call.js';
 import { fuzzyPickName, guessVerb } from './utilities/fuzzy-match.js';
 import { PickCommand } from './commands/pick.js';
 import { HackCommand } from './commands/hack.js';
+import { DisableCommand, BrickCommand } from './commands/disable.js';
 import { CastCommand } from './commands/cast.js';
 import { StanceCommand } from './commands/stance.js';
 import { FollowCommand, UnfollowCommand } from './commands/follow.js';
@@ -2596,6 +2597,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('end-call', EndCallCommand);
         CommandFactory.registerCommand('pick', PickCommand);
         CommandFactory.registerCommand('hack', HackCommand);
+        CommandFactory.registerCommand('disable', DisableCommand);
+        CommandFactory.registerCommand('brick', BrickCommand);
         CommandFactory.registerCommand('cast', CastCommand);
         CommandFactory.registerCommand('stance', StanceCommand);
         CommandFactory.registerCommand('surrender', SurrenderCommand);
@@ -5662,7 +5665,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // works the grid while you're back in the meat (the AR-drop exit).
         const remoteAgent = this.companions.find(c => c.kind === 'agent');
         if (remoteAgent && player.plane !== 'matrix') {
-            lines.push(`{cyan-fg}▣ DECK IN AR -- ${remoteAgent.npc.name} on the grid${remoteAgent.npc.objective ? ', working its directive' : ''}${hint(' ("jack in" to rejoin it, "recall" to fold it home)')}{/cyan-fg}`);
+            lines.push(`{lightblue-fg}▣ DECK IN AR -- ${remoteAgent.npc.name} on the grid${remoteAgent.npc.objective ? ', working its directive' : ''}${hint(' ("jack in" to rejoin it, "recall" to fold it home)')}{/lightblue-fg}`);
         }
         // Off-plane context: which reality you're in, your persona's Matrix
         // track (cold-sim damage lands there), and where your empty body lies.
@@ -5681,7 +5684,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             const track = jackedDeck
                 ? `  Deck A${jackedDeck.attack} S${jackedDeck.sleaze} D${jackedDeck.dataProcessing} F${jackedDeck.firewall} ${jackedDeck.deckSummary()}${player.simMode === 'hot' ? ' +biofeedback' : ''}${pgms}`
                 : `  (living persona -- damage is REAL stun)`;
-            lines.push(`{cyan-fg}▣ MATRIX ${(player.simMode ?? 'cold').toUpperCase()}-SIM${track} -- body at ${player.bodyRoom?.name ?? '???'}{/cyan-fg}`);
+            lines.push(`{lightblue-fg}▣ MATRIX ${(player.simMode ?? 'cold').toUpperCase()}-SIM${track} -- body at ${player.bodyRoom?.name ?? '???'}{/lightblue-fg}`);
         }
         else if (player.plane === 'astral') {
             lines.push(`{magenta-fg}✧ ASTRAL -- ${player.astralTicks} move${player.astralTicks === 1 ? '' : 's'} out -- body at ${player.bodyRoom?.name ?? '???'}{/magenta-fg}`);
@@ -5773,7 +5776,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             const dockW = mapWidth ?? 15;
             const lines = hosts.length > 0
                 ? hosts.map(h => hostDockLine(h, this.player, dockW))
-                : ['{cyan-fg}nothing overhead{/cyan-fg}'];
+                : ['{lightblue-fg}nothing overhead{/lightblue-fg}'];
             lines.push(caption(this.player.insideHost ? `inside ${this.player.insideHost.name}` : `on the grid from ${gridVicinity(this.player).name}`, mapWidth));
             this.setMapOverlay(lines);
             if (onTheGrid) {
@@ -6275,7 +6278,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'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['pan'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
+        { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['mark'], ['disable'], ['brick'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['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/device.js

@@ -126,6 +126,16 @@ export class Device {
     structure;
     armor;
     _barrierDamage = 0;
+    /**
+     * THE MATRIX CONDITION MONITOR (p.228): 8 + (Device Rating / 2)
+     * boxes, resisted with Device Rating + Firewall, filled by a Data
+     * Spike (commands/disable.ts, "brick"). Full = BRICKED: "the device
+     * ceases functioning" -- a camera records nothing, a smartgun sparks
+     * and dies -- but "a lock stays locked" (p.228): bricking is never a
+     * way through a maglock. Repaired on the bench (rest.ts), never by a
+     * reboot. A ward is not electronics and has no monitor at all.
+     */
+    _matrixDamage = 0;
     /**
      * THE LOCKSMITH EXTENDED TEST IN PROGRESS (p.48, p.359-360): picking a
      * maglock by hand accumulates hits toward Rating x 2 across attempts,
@@ -207,6 +217,33 @@ export class Device {
      * exact fault this codebase keeps having to close (see the gun in
      * aroTags, AKfemBJJWJP99nx8K).
      */
+    // ---- The Matrix condition monitor (commands/disable.ts) ----
+    /** p.228: 8 + (Device Rating / 2), rounded up as the deck's is. 0 for
+     *  a thing with no rating (a ward): nothing there to brick. */
+    get matrixMonitor() {
+        return this.rating > 0 ? 8 + Math.ceil(this.rating / 2) : 0;
+    }
+    get matrixDamage() {
+        return this._matrixDamage;
+    }
+    /** Returns boxes actually taken. */
+    takeMatrixDamage(boxes) {
+        if (this.matrixMonitor <= 0)
+            return 0;
+        const taken = Math.max(0, Math.floor(boxes));
+        this._matrixDamage = Math.min(this.matrixMonitor, this._matrixDamage + taken);
+        return taken;
+    }
+    get isBricked() {
+        return this.matrixMonitor > 0 && this._matrixDamage >= this.matrixMonitor;
+    }
+    /** Bench work (rest.ts): the whole monitor, at once. */
+    repairMatrix() {
+        this._matrixDamage = 0;
+    }
+    matrixSummary() {
+        return this.matrixMonitor > 0 ? `${this._matrixDamage}/${this.matrixMonitor} boxes` : '';
+    }
     broadcastsAro() {
         return this.wireless && this.rating > 0;
     }
@@ -328,11 +365,13 @@ export class Device {
         const text = hint(AFFORDANCE_FLAVOR[this.kind].hint);
         return text.length > 0 ? text : undefined;
     }
-    /** Persistence-only: one flag in, nothing out. */
+    /** Persistence-only: flags in, nothing out. */
     restoreState(state) {
         this.open = state.open;
         if (state.damage !== undefined)
             this._barrierDamage = Math.max(0, Math.min(this.structure, Math.floor(state.damage)));
+        if (state.bricked !== undefined)
+            this._matrixDamage = state.bricked ? this.matrixMonitor : 0;
     }
 }
 //# sourceMappingURL=device.js.map

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

@@ -41,6 +41,10 @@ export class Host {
     marksBy = new Map();
     /** player name -> marks the host holds on that player. */
     marksOn = new Map();
+    /** Personas whose Matrix Search (p.241, commands/search.ts) turned up
+     *  this host's files: the archive is listed for them from then on. A
+     *  cracked host lists it for everyone. Session-only. */
+    searchedBy = new Set();
     /** Walls up: the host holds a mark on an intruder and its ice is hunting. */
     alert = false;
     /** IC running now, by kind name. Names, not actors -- until increment 5. */

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

@@ -43,6 +43,12 @@ export class Item extends AbstractItem {
     // A jammed firearm can't fire (fists until cleared); "reboot" clears
     // every jammed device you carry, in the lull.
     jammed = false;
+    // BRICKED (p.228, commands/disable.ts "brick"): a Data Spike filled the
+    // device's Matrix condition monitor. Dead electronics -- a smartgun
+    // "sparks, crackles, and smokes" and will not fire -- until bench
+    // work (rest.ts). A reboot does NOT clear it; that is the whole
+    // difference from `jammed`.
+    bricked = false;
     _transferable;
     // New currency-related fields
     _currencyAmount = 0;

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

@@ -8,6 +8,7 @@ import { hint } from '../utilities/hints.js';
 import { Category } from '../types/shared/item-enum.js';
 import { Logger } from '../utilities/logger.js';
 import { CALL_ICON, CALL_COLOR } from '../utilities/comm-style.js';
+import { FEED_COLOR } from '../utilities/matrix-style.js';
 // The Physical limit already lives here (subduing, p.195) -- imported
 // rather than re-derived so meat combat and the grapple cannot drift
 // into two different formulas for the same canon number.
@@ -2851,7 +2852,7 @@ export class Player extends AbstractPlayer {
             // as before -- only the human's log line is dropped.
             if (quiet)
                 return;
-            this.logger.logWithColor(`${actor.name} ${verb} ${details}`, 'cyan');
+            this.logger.logWithColor(`${actor.name} ${verb} ${details}`, FEED_COLOR);
         }
     }
     performAction(verb, details, opts) {

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

@@ -469,6 +469,12 @@ export class Room extends AbstractRoom {
     warded = false;
     // See IRoomConstructorConfig.watched (utilities/surveillance.ts).
     watched = false;
+    /** The cluster is LOOPED by Control Device (commands/disable.ts): the
+     *  house sees empty hallways until the run ends. Session-only. */
+    camerasLooped = false;
+    /** The cluster is BRICKED by a Data Spike (p.228): dead lenses, until
+     *  somebody's bench work nobody in this run is doing. Session-only. */
+    camerasBricked = false;
     /**
      * THE HOST STANDING OVER THIS ROOM, as an object (models/host.ts) --
      * increment 1 of the Matrix position model. Every host field this class

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

@@ -256,7 +256,7 @@ export function aroBlock(scene, actor, room) {
     const tags = aroTags(scene, actor, room);
     if (tags.length === 0)
         return '';
-    return `{cyan-fg}AR OVERLAY:{/cyan-fg}\n${tags.map(t => `  {cyan-fg}${t}{/cyan-fg}`).join('\n')}`;
+    return `{lightblue-fg}AR OVERLAY:{/lightblue-fg}\n${tags.map(t => `  {lightblue-fg}${t}{/lightblue-fg}`).join('\n')}`;
 }
 /** Gear that talks to the grid on its own, lying LOOSE in the room.
  *  Weapons are absent here because a carried one is handled above, as

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

@@ -475,7 +475,7 @@ export class CombatEncounter {
             // A persona has no metres to spend: the grid sees no distance.
             const ground = this.arena.kind === 'room' ? `; ${this.movementLine(p.actor)}` : '';
             const budgetLine = `Your Action Phase -- Combat Turn ${this.turn}, pass ${this.pass}, Initiative ${p.score}. ${this.budget.describe()}${ground}. "end turn" when you're done.`;
-            this.logger.log(`\n{cyan-fg}${budgetLine}{/cyan-fg}`, { actor: p.actor.name });
+            this.logger.log(`\n{yellow-fg}${budgetLine}{/yellow-fg}`, { actor: p.actor.name });
             this.scene.updateStatus();
             this.onHumanPhase?.(p.actor, this);
             return;
@@ -742,7 +742,7 @@ export class CombatEncounter {
             return undefined;
         if (this.phaseActor === player && this.budget) {
             const ground = this.arena.kind === 'room' ? ` · ${player.movementLeftMeters} m` : '';
-            return `{cyan-fg}⏱ YOUR PHASE{/cyan-fg} T${this.turn}/P${this.pass} Init ${p.score} · ${this.budget.describe()}${ground} · "end turn"`;
+            return `{yellow-fg}⏱ YOUR PHASE{/yellow-fg} T${this.turn}/P${this.pass} Init ${p.score} · ${this.budget.describe()}${ground} · "end turn"`;
         }
         const who = this.phaseActor ? `${this.phaseActor.name} acting` : 'resolving';
         return `⏱ COMBAT T${this.turn}/P${this.pass} Init ${p.score} · ${who}${p.fullDefenseTurn === this.turn ? ' · FULL DEFENSE' : ''}`;

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

@@ -106,6 +106,6 @@ export function hostDockLine(room, actor, width) {
     const tag = room.hostCracked ? ' open' : marks > 0 ? ` ${marks}/3` : '';
     const raw = `${inside ? '▣' : '●'} ${room.name} HR${room.hostRating}${tag}`;
     const cut = [...raw].slice(0, Math.max(4, width)).join('');
-    return `{cyan-fg}${cut}{/cyan-fg}`;
+    return `{lightblue-fg}${cut}{/lightblue-fg}`;
 }
 //# sourceMappingURL=grid-reach.js.map