@maka/maka-cli 5.183.0 → 5.185.0

package/bundle/typescript/package.json

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

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

@@ -64,14 +64,14 @@ export class ArCommand extends Command {
             return `Overlay back on -- over nothing. No commlink, no deck, no AR: you're reading the street with your eyes like it's 2050.`;
         }
         const tags = aroTags(this.scene, actor, actor.currentLocation);
-        const head = `{cyan-fg}The overlay blinks back in.{/cyan-fg}`;
+        const head = `{lightblue-fg}The overlay blinks back in.{/lightblue-fg}`;
         // Turning AR back on while silent is the other moment the question
         // lands -- you have just done the thing you were unsure was allowed.
         const note = silentAndSeeingNote(actor);
         if (tags.length === 0) {
-            return [head, `{cyan-fg}Nothing here is talking -- a dead patch of street.{/cyan-fg}`, note].filter(Boolean).join('\n');
+            return [head, `{lightblue-fg}Nothing here is talking -- a dead patch of street.{/lightblue-fg}`, note].filter(Boolean).join('\n');
         }
-        return [head, ...tags.map(t => `  {cyan-fg}${t}{/cyan-fg}`), note].filter(Boolean).join('\n');
+        return [head, ...tags.map(t => `  {lightblue-fg}${t}{/lightblue-fg}`), note].filter(Boolean).join('\n');
     }
 }
 /**
@@ -105,11 +105,11 @@ export class ArosCommand extends Command {
         const note = silentAndSeeingNote(actor);
         const tags = aroTags(this.scene, actor, actor.currentLocation);
         if (tags.length === 0) {
-            return [`{cyan-fg}Nothing here is talking -- a dead patch of street.{/cyan-fg}`, note].filter(Boolean).join('\n');
+            return [`{lightblue-fg}Nothing here is talking -- a dead patch of street.{/lightblue-fg}`, note].filter(Boolean).join('\n');
         }
         return [
-            `{cyan-fg}AR OVERLAY:{/cyan-fg}`,
-            ...tags.map(t => `  {cyan-fg}${t}{/cyan-fg}`),
+            `{lightblue-fg}AR OVERLAY:{/lightblue-fg}`,
+            ...tags.map(t => `  {lightblue-fg}${t}{/lightblue-fg}`),
             note,
         ].filter(Boolean).join('\n');
     }

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

@@ -25,7 +25,7 @@ export class DelayCommand extends Command {
             return `Too late to delay -- you've already acted this phase (${budget.ledger()}). "end turn" instead.`;
         }
         if (this.scene.isHumanControlled(actor)) {
-            this.logger.log(`{cyan-fg}You hold your action, watching.{/cyan-fg}`, { actor: actor.name });
+            this.logger.log(`{yellow-fg}You hold your action, watching.{/yellow-fg}`, { actor: actor.name });
         }
         await enc.delayPhase(actor);
         return this.scene.isHumanControlled(actor) ? '' : `${actor.name} holds their action.`;

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

@@ -148,8 +148,11 @@ export class DisableCommand extends Command {
         const host = t.kind === 'device' ? t.host : t.kind === 'camera' ? t.master : undefined;
         if (host) {
             host.hostAlert = true;
-            if (made)
+            if (made) {
                 host.hostMarksOn.set(actor.name, Math.min(MAX_MARKS, (host.hostMarksOn.get(actor.name) ?? 0) + 1));
+                // Made is seen (Host.spotted) -- the ice hunts this persona now.
+                host.host?.spotted.add(actor.name);
+            }
         }
         if (t.kind === 'gun' && made) {
             actor.panMarksBy.set(t.owner.name, Math.min(MAX_MARKS, (actor.panMarksBy.get(t.owner.name) ?? 0) + 1));
@@ -180,7 +183,7 @@ export class DisableCommand extends Command {
         const defence = this.defence(t);
         const defenceRoll = rollPool(defence.pool);
         const net = roll.hits - defenceRoll.hits;
-        actor.performAction('takes control of a device', name);
+        actor.performAction('takes control of a device', name, { quiet: this.scene.isHumanControlled(actor) });
         if (this.scene.isHumanControlled(actor)) {
             this.logger.meta(`Control Device (Electronic Warfare + Intuition [Sleaze])${gridNote(grid)}: ${formatRoll(roll)}`);
             this.logger.meta(`${defence.label}: ${formatRoll(defenceRoll)} -- net ${net >= 0 ? '+' : ''}${net}`);
@@ -236,7 +239,7 @@ export class DisableCommand extends Command {
         const defence = this.defence(t);
         const defenceRoll = rollPool(defence.pool);
         const net = roll.hits - defenceRoll.hits;
-        actor.performAction('throws a Data Spike', name);
+        actor.performAction('throws a Data Spike', name, { quiet: this.scene.isHumanControlled(actor) });
         if (this.scene.isHumanControlled(actor)) {
             this.logger.meta(`Data Spike (Cybercombat + Logic [Attack ${limit}])${gridNote(grid)}: ${formatRoll(roll)}`);
             this.logger.meta(`${defence.label}: ${formatRoll(defenceRoll)} -- net ${net >= 0 ? '+' : ''}${net}`);

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

@@ -92,7 +92,7 @@ export class DownloadCommand extends Command {
         // is that nobody could find the file should say what it can see.
         const query = args.join(' ').trim();
         if (query.length === 0) {
-            const lines = [`{cyan-fg}Within reach to pull down:{/cyan-fg}`];
+            const lines = [`{lightblue-fg}Within reach to pull down:{/lightblue-fg}`];
             for (const i of loose)
                 lines.push(`  ${planeTintItemName(i, actor.plane)} -- loose on the grid here`);
             for (const c of carried)
@@ -134,11 +134,11 @@ export class DownloadCommand extends Command {
         this.scene.updateStatus();
         return fromSprite
             ? [
-                `{cyan-fg}${fromSprite.npc.name} opens its hands and the data pours out of them.{/cyan-fg}`,
+                `{lightblue-fg}${fromSprite.npc.name} opens its hands and the data pours out of them.{/lightblue-fg}`,
                 `You pull {bold}{underline}${item.name}{/underline}{/bold} down onto a chip -- meat-world cargo now.${hint(` (You can "give ${item.name}" to somebody standing in front of you.)`)}`,
             ].join('\n')
             : [
-                `{cyan-fg}You pull {bold}{underline}${item.name}{/underline}{/bold} down off the grid -- written to a chip.{/cyan-fg}`,
+                `{lightblue-fg}You pull {bold}{underline}${item.name}{/underline}{/bold} down off the grid -- written to a chip.{/lightblue-fg}`,
                 hint(`(Meat-world cargo now: carry it, stash it, or "give" it to somebody.)`),
             ].join('\n');
     }

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

@@ -49,7 +49,7 @@ export class EndTurnCommand extends Command {
             // Logged now rather than returned: the phases that follow announce
             // themselves while this command is still running, and a return
             // value would land under them, out of order.
-            this.logger.log(`{cyan-fg}You end your Action Phase${budget && budget.spent.length > 0 ? ` -- ${ledger}` : ' -- nothing spent'}.{/cyan-fg}`, { actor: actor.name });
+            this.logger.log(`{yellow-fg}You end your Action Phase${budget && budget.spent.length > 0 ? ` -- ${ledger}` : ' -- nothing spent'}.{/yellow-fg}`, { actor: actor.name });
         }
         await enc.endPhase(actor);
         return this.scene.isHumanControlled(actor) ? '' : `${actor.name} ends their Action Phase.`;

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

@@ -64,7 +64,7 @@ export class EnterHostCommand extends Command {
         const marks = target.hostMarksBy.get(actor.name) ?? 0;
         if (marks < 1 && !target.hostCracked && !target.hostSanctioned) {
             return [
-                `{cyan-fg}${hostLabel(target, { capital: true })} doesn't know you. Its architecture has no door shaped like your icon.{/cyan-fg}`,
+                `{lightblue-fg}${hostLabel(target, { capital: true })} doesn't know you. Its architecture has no door shaped like your icon.{/lightblue-fg}`,
                 hint(`A host opens to anyone holding a MARK on it (p.239) -- "mark ${target.name}" softens it, or "hack" takes one by force.`),
             ].join('\n');
         }
@@ -79,14 +79,15 @@ export class EnterHostCommand extends Command {
         // you there). currentLocation is never written -- it is the body's.
         actor.matrixPosition = { kind: 'host', host: target.host, from: actor.currentGrid };
         movePersonaWith(this.game ?? undefined, actor);
-        actor.performAction('enters a host', `icon crossing into ${target.name}'s architecture`);
+        actor.performAction('enters a host', `icon crossing into ${target.name}'s architecture`, { quiet: this.scene.isHumanControlled(actor) });
         this.logger.write(`${actor.name} entered the host at ${target.name}.`);
         this.scene.updateStatus();
+        // ONE LINE (2026-09-13, "too much text"): the crossing, and the
+        // coaching behind the hints toggle.
         return [
-            `{cyan-fg}You cross into ${hostLabel(target, { capital: false })}.{/cyan-fg}`,
-            `{cyan-fg}The outside grid folds shut behind you -- the icons in reach, the PANs, the personas out on the grid: all of it gone, not hidden. In here there is only what the host keeps.{/cyan-fg}`,
-            hint(`"look" reads the space you're standing in now. "exit" puts you back on the grid.`),
-        ].join('\n');
+            `{lightblue-fg}You cross into ${hostLabel(target, { capital: false })} -- the outside grid folds shut behind you.{/lightblue-fg}`,
+            hint(`(In here there is only what the host keeps. "look" reads it; "exit" puts you back on the grid.)`),
+        ].filter(Boolean).join('\n');
     }
     /**
      * The host this verb means. Bare `enter` takes the one under your feet
@@ -109,14 +110,14 @@ export class EnterHostCommand extends Command {
             const over = hostOver(gridVicinity(this.actor)) ?? hostOver(here);
             if (over)
                 return over;
-            return `{cyan-fg}Thin grid here -- no host stands over ${gridVicinity(this.actor).name}.{/cyan-fg} ${hint(`Overhead: ${roster} -- "enter <name>" crosses into any of them from here.`)}`;
+            return `{lightblue-fg}Thin grid here -- no host stands over ${gridVicinity(this.actor).name}.{/lightblue-fg} ${hint(`Overhead: ${roster} -- "enter <name>" crosses into any of them from here.`)}`;
         }
         const host = resolveHostInReach(rooms, this.actor, named);
         if (host)
             return host;
         const street = Object.values(rooms).find(r => r.name.toLowerCase() === named.toLowerCase());
         if (street)
-            return `{cyan-fg}${street.name} has no host over it -- nothing to enter. Overhead: ${roster}.{/cyan-fg}`;
+            return `{lightblue-fg}${street.name} has no host over it -- nothing to enter. Overhead: ${roster}.{/lightblue-fg}`;
         return `No host called "${named}" overhead. ${hint(`Overhead: ${roster}.`)}`;
     }
 }
@@ -148,13 +149,10 @@ export class ExitHostCommand extends Command {
         const from = actor.matrixPosition?.kind === 'host' ? actor.matrixPosition.from : undefined;
         actor.matrixPosition = { kind: 'grid', grid: from };
         movePersonaWith(this.game ?? undefined, actor);
-        actor.performAction('exits a host', `icon surfacing out of ${host.name}'s architecture`);
+        actor.performAction('exits a host', `icon surfacing out of ${host.name}'s architecture`, { quiet: this.scene.isHumanControlled(actor) });
         this.logger.write(`${actor.name} exited the host at ${host.name}.`);
         this.scene.updateStatus();
-        return [
-            `{cyan-fg}You step back out of ${hostLabel(host, { capital: false })} and onto the grid -- your body still sits in ${actor.currentLocation.name}.{/cyan-fg}`,
-            `{cyan-fg}The host seals behind you: one icon again, whatever you saw in there now on the other side of its wall.{/cyan-fg}`,
-        ].join('\n');
+        return `{lightblue-fg}You step back out of ${hostLabel(host, { capital: false })} onto the grid; the host seals behind you. Your body still sits in ${actor.currentLocation.name}.{/lightblue-fg}`;
     }
 }
 //# sourceMappingURL=enter-host.js.map

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

@@ -173,7 +173,7 @@ export class HackCommand extends BypassCommand {
             const burned = this.actor.burnedAttributeRefusal(mode === 'attack' ? 'attack' : 'sleaze');
             if (burned)
                 return burned;
-            this.actor.performAction('hacks the host', room.name);
+            this.actor.performAction('hacks the host', room.name, { quiet: this.scene.isHumanControlled(this.actor) });
             const attempt = await this.hostIntrusionRoll(mode, declared, room);
             const success = attempt.success;
             // GOD BILLS THE DEFENDER'S HITS (p.231-232): "your OS increases by
@@ -197,6 +197,9 @@ export class HackCommand extends BypassCommand {
                     // CAUGHT from a user who merely holds a key, so the sentence
                     // has to be true.
                     room.hostMarksOn.set(this.actor.name, Math.min(MAX_MARKS, (room.hostMarksOn.get(this.actor.name) ?? 0) + 1));
+                    // Being made is being SEEN (Host.spotted): the ice hunts this
+                    // persona from here, not merely the intrusion.
+                    room.host?.spotted.add(this.actor.name);
                     this.actor.noteConditionChanged();
                     this.actor.sneaking = false;
                     this.scene.addWorldEvent(`${hostLabel(room, { capital: true })} MADE ${this.actor.name} mid-intrusion -- alarm flagged, ice hunting.`);
@@ -276,7 +279,7 @@ export class HackCommand extends BypassCommand {
                 if (marksNow >= 1)
                     lines.push(`  One mark is the door: "enter" walks your persona inside (p.239).`);
                 if (perception > 0)
-                    lines.push(`  {cyan-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what this node is (p.240).{/cyan-fg}`);
+                    lines.push(`  {lightblue-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what this node is (p.240).{/lightblue-fg}`);
                 if (forcedDv > 0)
                     lines.push(`  The forcing burns ${forcedDv} DV into the architecture -- a host has no boards to brick, so it only announces you louder.`);
                 lines.push(`  ${MAX_MARKS - marksNow} more and its architecture stops asking who you are.${hint(` ("hack for ${MAX_MARKS - marksNow}" reaches for the rest at once -- ${declarationPenalty(MAX_MARKS - marksNow, this.actor.hasQuality(GO_BIG_QUALITY))} dice.)`)}`);
@@ -340,13 +343,13 @@ export class HackCommand extends BypassCommand {
                 lines.push(`  ${iconLocks.length} ${iconLocks.length === 1 ? 'lock hangs' : 'locks hang'} off it, still sealed -- each its own icon behind its own rating: ${iconLocks.map(d => d.name).join(', ')}.${hint(` ("hack <lock>" from in here keys one; the host's key is not the door's.)`)}`);
             }
             if (vaultedFiles.length > 0) {
-                lines.push(`  {cyan-fg}The data vault unseals -- ${vaultedFiles.map(i => i.name).join(', ')} spill${vaultedFiles.length === 1 ? 's' : ''} into the open.${hint(` Yours to "take".`)}{/cyan-fg}`);
+                lines.push(`  {lightblue-fg}The data vault unseals -- ${vaultedFiles.map(i => i.name).join(', ')} spill${vaultedFiles.length === 1 ? 's' : ''} into the open.${hint(` Yours to "take".`)}{/lightblue-fg}`);
             }
             // AND WHAT THE CRACK DID NOT REACH: a wired site's data sits on an
             // air-gapped box the host never held (p.233) -- say so, or the next
             // "take" reads as a contradiction.
             if (room.offlineServer && room.inventory.getAllItems().some(i => i.plane === 'matrix')) {
-                lines.push(`  {cyan-fg}Nothing on the grid side of the vault -- whatever this place keeps sits on the ${room.offlineServer}, an air-gapped box with no Matrix presence. Your BODY has to be in ${room.name} to cable in (p.233).{/cyan-fg}`);
+                lines.push(`  {lightblue-fg}Nothing on the grid side of the vault -- whatever this place keeps sits on the ${room.offlineServer}, an air-gapped box with no Matrix presence. Your BODY has to be in ${room.name} to cable in (p.233).{/lightblue-fg}`);
             }
             // THE FEEDS ARE A REAL GAIN AND WERE NEVER MENTIONED
             // (BpR5cjhYuvgCyDSZc, 7aNWnDSHeZMYmS2De: "what have I gained?").
@@ -540,7 +543,7 @@ export class HackCommand extends BypassCommand {
             ? Math.max(1, actor.getAttackPool() + silence + actor.bonus('matrix-attack') + declarePenalty)
             : Math.max(1, actor.logic + actor.skillRating('hacking') + actor.bonus('hacking') + actor.bonus('matrix-sleaze')
                 + silence + actor.woundModifier - actor.sustainingPenalty + declarePenalty);
-        actor.performAction('works a slaved icon', device.name);
+        actor.performAction('works a slaved icon', device.name, { quiet: this.scene.isHumanControlled(actor) });
         const roll = rollPool(pool, limit, { gremlins: actor.deckGremlins });
         // From the grid the slave borrows its master's numbers where they are
         // higher (p.233); inside, it stands alone (Data Trails p.87-88).
@@ -606,7 +609,7 @@ export class HackCommand extends BypassCommand {
         else {
             const perception = freeMatrixPerceptionHits(netHits);
             if (perception > 0)
-                lines.push(`  {cyan-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what it guards (p.240).{/cyan-fg}`);
+                lines.push(`  {lightblue-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what it guards (p.240).{/lightblue-fg}`);
         }
         // TWO MARKS COMMAND IT (p.238 Control Device: 1 mark for a Free
         // action, 2 for a Simple, 3 for a Complex -- and unlocking a maglock
@@ -765,7 +768,7 @@ export class HackCommand extends BypassCommand {
         // Intuition + Firewall against a sleaze, Willpower + Firewall
         // against a smash (p.240 / p.238), and no limit on either.
         const defense = rollPool(target.getPanDefensePool(mode === 'attack' ? 'attack' : 'sleaze'));
-        actor.performAction('runs a PAN intrusion', target.name);
+        actor.performAction('runs a PAN intrusion', target.name, { quiet: this.scene.isHumanControlled(actor) });
         this.logger.write(`${actor.name} PAN-hacks ${target.name}: ${attack.hits} vs ${defense.hits} (silent=${target.runningSilent}).`);
         // Dice anatomy to the Mechanics ticker (readability pass) --
         // player-gated like every roll site: an NPC's probe isn't your dice.

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

@@ -0,0 +1,110 @@
+import { Command } from './command.js';
+import { hint } from '../utilities/hints.js';
+import { rollPool, formatRoll } from '../utilities/dice.js';
+import { accrueOverwatch } from '../utilities/overwatch.js';
+import { leaveMatrix } from '../utilities/planes.js';
+import { billAction, encounterOf } from '../utilities/action-cost.js';
+import { isSpotted } from '../utilities/ic.js';
+import { MAX_MARKS } from '../utilities/marks.js';
+import { hostLabel } from '../utilities/grid-names.js';
+/**
+ * HIDE (SR5 p.240, RAG-checked 2026-09-14): a Complex Action, no marks
+ * required, Electronic Warfare + Intuition [Sleaze] v. Intuition + Data
+ * Processing. "If you succeed, the target loses track of you and must
+ * perform a new Matrix Perception action to find you." And the one hard
+ * limit the book puts on it: "You can't hide from an icon that has a
+ * mark on you, so you'll need to clear those before you can try this."
+ *
+ * WHY IT EXISTS HERE (the "constantly in combat" report, 2026-09-14):
+ * a host that has SPOTTED a persona (Host.spotted) hunts it with every
+ * program it can launch, and nothing but leaving ended that. Canon's
+ * answer is this action -- drop off the host's scope, and its ice has
+ * nothing to swing at until Patrol finds you again (which, on an alerted
+ * host, it tries every action: Data Trails p.86, ic.ts ambientPatrol).
+ *
+ * THE DEFENDER IS THE HOST, and a host has no Intuition: its rating
+ * stands in, the same engine ruling matrix-intrusion.ts hostDefensePool
+ * already makes for the intrusion roll (Host Rating + Firewall). Here it
+ * is Host Rating + Data Processing, because the book names Data
+ * Processing for this test. The host and its IC share spotting (p.247),
+ * so hiding from the host hides you from every program at once.
+ *
+ * A SLEAZE ACTION: GOD bills the defender's hits (p.231-232), and a
+ * failure is a blown Sleaze -- the target gets one free mark on you and
+ * spots you (p.236). Failing to hide from a host that could see you
+ * makes it hold you tighter; that is the book's own tension, not ours.
+ */
+export class HideCommand extends Command {
+    static verb = 'hide';
+    static description = 'Hide (Complex Action, SR5 p.240): Electronic Warfare + Intuition [Sleaze] v. the host\'s Rating + Data Processing. Win and the host loses track of your persona -- its ice has nothing to swing at until Patrol finds you again. Impossible while the host holds a mark on you. A Sleaze action: GOD counts it, and a miss hands the host a mark.';
+    async execute(_args = []) {
+        const actor = this.actor;
+        if (actor.plane !== 'matrix') {
+            return `Hide is a Matrix action -- it takes a persona to lose. ${hint(`"jack in" first; in the meat, "sneak".`)}`;
+        }
+        const host = actor.hostInside;
+        if (!host) {
+            return `Nothing out here has you. Hide is for shaking an icon that has SPOTTED you -- a host's ice, once it's made you inside.`;
+        }
+        const room = host.over;
+        if (!isSpotted(room, actor)) {
+            return `${hostLabel(room, { capital: true })} hasn't found you -- there is nothing to hide from yet.${actor.runningSilent ? '' : hint(` ("silent" is what keeps it that way: a loud icon is spotted with no test, p.235.)`)}`;
+        }
+        const held = room.hostMarksOn.get(actor.name) ?? 0;
+        if (held > 0) {
+            return `You can't hide from an icon that has a MARK on you (p.240) -- ${hostLabel(room)} holds ${held} on your persona. Those come off with a reboot, not a dodge.${hint(` ("jack out" reboots; "exit" leaves the host.)`)}`;
+        }
+        // Marker IC eats Sleaze; a bracket of 0 permits no hits at all.
+        const burned = actor.burnedAttributeRefusal('sleaze');
+        if (burned)
+            return burned;
+        const bill = billAction(this.scene, actor, 'complex', 'Hide');
+        if (bill)
+            return bill;
+        const ew = actor.skillRating('electronic-warfare');
+        const pool = Math.max(1, actor.intuition + (ew > 0 ? ew : -1)
+            + actor.matrixActionPenalty + actor.woundModifier - actor.sustainingPenalty);
+        const limit = actor.matrixAttribute('sleaze');
+        const attempt = rollPool(pool, limit, { gremlins: actor.deckGremlins });
+        const defence = rollPool(room.hostRating + room.hostAttributes().dataProcessing);
+        if (this.scene.isHumanControlled(actor)) {
+            this.logger.meta(`Hide -- Electronic Warfare + Intuition [Sleaze]: ${formatRoll(attempt)}`);
+            this.logger.meta(`  v. ${hostLabel(room)} (Host Rating + Data Processing, rating standing in for Intuition): ${formatRoll(defence)}`);
+        }
+        actor.performAction('tries to hide', `persona folding into ${hostLabel(room)}'s traffic`, { quiet: this.scene.isHumanControlled(actor) });
+        const god = accrueOverwatch(this.scene, actor, defence.hits, 'hide (sleaze)');
+        if (god.converged) {
+            return [`The hide never lands --`, ...god.lines, ...leaveMatrix(this.scene, actor, { forced: true, reason: `GOD force-reboots your persona --` })].join('\n');
+        }
+        if (attempt.hits <= defence.hits) {
+            // p.236: a blown Sleaze action is NOTICED -- one free mark, and it
+            // certainly still sees you.
+            room.hostMarksOn.set(actor.name, Math.min(MAX_MARKS, held + 1));
+            room.host?.spotted.add(actor.name);
+            actor.noteConditionChanged();
+            this.logger.write(`${actor.name} failed to hide in ${room.name}: ${attempt.hits} v ${defence.hits} -- host mark ${held + 1}.`);
+            this.scene.updateStatus();
+            return [
+                `{red-fg}You fold into the traffic and the host folds with you -- it never lost you, and now it holds a MARK on your persona.{/red-fg}`,
+                `  No hiding from an icon that has a mark on you (p.240). The ice stays on you.`,
+                ...god.lines,
+            ].join('\n');
+        }
+        room.host?.spotted.delete(actor.name);
+        room.host?.justHid.add(actor.name);
+        actor.noteConditionChanged();
+        // Out of the host's sight is out of its fight: nothing may swing at
+        // an icon it cannot see. The encounter closes on its own when nobody
+        // in view is left (host-combat.ts hostKeepsFighting).
+        encounterOf(this.scene, actor)?.leave(actor);
+        this.logger.write(`${actor.name} hid from ${room.name}'s host: ${attempt.hits} v ${defence.hits}.`);
+        this.scene.addWorldEvent(`${host.name}'s ice lost ${actor.name} in the traffic.`);
+        this.scene.updateStatus();
+        return [
+            `{lightblue-fg}You drop into the host's own traffic and become one more packet in a million. ${hostLabel(room, { capital: true })} loses you.{/lightblue-fg}`,
+            `  Its ice has nothing to swing at -- but the host is still awake, and Patrol is looking every action now.${hint(` ("silent" keeps a sweep from seeing you for free; "search" is possible while it looks.)`)}`,
+            ...god.lines,
+        ].join('\n');
+    }
+}
+//# sourceMappingURL=hide.js.map

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

@@ -53,7 +53,7 @@ export class HopCommand extends Command {
             actor.performAction('hops grids', `persona blinking across to ${target.name}`);
             this.logger.write(`${actor.name} hopped to ${target.key} (legal, ${tier}).`);
             this.scene.updateStatus();
-            return `{cyan-fg}The sky changes texture and you're on ${target.name}.{/cyan-fg}${target.userPenalty ? ` ${hint(`Public grid: -2 on everything you do out here.`)}` : ''}`;
+            return `{lightblue-fg}The sky changes texture and you're on ${target.name}.{/lightblue-fg}${target.userPenalty ? ` ${hint(`Public grid: -2 on everything you do out here.`)}` : ''}`;
         }
         // ILLEGAL HOP (p.240): Hack on the Fly against the grid itself.
         const burned = actor.burnedAttributeRefusal('sleaze');
@@ -87,7 +87,7 @@ export class HopCommand extends Command {
         this.logger.write(`${actor.name} hopped to ${target.key} (illegal, ${attempt.hits} v ${defence.hits}).`);
         this.scene.updateStatus();
         return [
-            `{cyan-fg}You slip through a seam nobody sold you and come up on ${target.name}.{/cyan-fg}`,
+            `{lightblue-fg}You slip through a seam nobody sold you and come up on ${target.name}.{/lightblue-fg}`,
             ...bill.lines,
         ].join('\n');
     }

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/search.js

@@ -175,7 +175,7 @@ export class SearchCommand extends Command {
         // 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`);
+        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) {
@@ -211,7 +211,7 @@ export class SearchCommand extends Command {
         // 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 or get out first.`;
+            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.`;
         }
         if (this.actor.plane === 'matrix')
             return this.matrixSearch();
@@ -313,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

@@ -117,6 +117,12 @@ export class TapCommand extends Command {
                 // p.236: a blown Sleaze action is NOTICED. The camera screams to
                 // its master, which is the same alarm hack.ts raises.
                 host.hostAlert = true;
+                // The line below promises "it holds a mark on your persona now"
+                // (p.236, a blown Sleaze's free mark) -- and a mark is a sighting
+                // (Host.spotted). Both written, so the sentence is true and the
+                // ice hunts THIS persona rather than the intrusion in general.
+                host.hostMarksOn.set(actor.name, Math.min(3, (host.hostMarksOn.get(actor.name) ?? 0) + 1));
+                host.host?.spotted.add(actor.name);
                 actor.sneaking = false;
                 this.scene.addWorldEvent(`Something forced the cameras in ${room.name} -- ${hostLabel(host)} flagged an intrusion and its ice is hunting.`);
                 this.scene.updateStatus();
@@ -158,9 +164,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 +175,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/engine-version.js

@@ -449,5 +449,15 @@
 //   Combat Turn. IC no longer act once per player command, never speak,
 //   and a failed IC attack damages the program (p.247). Ice NPCs are no
 //   longer generated; the vault host's rating is its guard.
-export const ENGINE_VERSION = '1.53.0';
+// 1.54.0 (2026-09-14): ALERT IS NOT SPOTTED. A host's ice hunts only the
+//   personas the host has SEEN (Host.spotted, shared by all its IC,
+//   p.247): a blown Sleaze's free mark, a Patrol sighting, Probe's grip.
+//   A successful Attack (Brute Force, the default stance) alerts the host
+//   without spotting you (p.236); an alerted host's Patrol then runs
+//   Matrix Perception every action (DT p.86) -- a loud icon is seen with
+//   no test, a silent one gets its opposed roll, tie to the hider -- and
+//   the host fight opens only on a sighting and closes when nobody in
+//   view is left. New verb: "hide" (p.240). Matrix Search inside a host
+//   is reachable again.
+export const ENGINE_VERSION = '1.54.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -177,6 +177,7 @@ import { CounterspellCommand } from './commands/counterspell.js';
 import { BreachCommand } from './commands/breach.js';
 import { EmoteCommand } from './commands/emote.js';
 import { OverwatchCommand } from './commands/overwatch.js';
+import { HideCommand } from './commands/hide.js';
 import { MarkCommand } from './commands/mark.js';
 import { SnoopCommand } from './commands/snoop.js';
 import { TapCommand } from './commands/tap.js';
@@ -2746,6 +2747,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // GOD's tally ("os" for the tabletop shorthand).
         CommandFactory.registerCommand('overwatch', OverwatchCommand);
         CommandFactory.registerCommand('os', OverwatchCommand);
+        // Hide (SR5 p.240): drop off a host that has spotted you.
+        CommandFactory.registerCommand('hide', HideCommand);
         // MAtrix Recognition Keys (canon p.235-236).
         CommandFactory.registerCommand('mark', MarkCommand);
         // Camera feeds you own (surveillance).
@@ -5665,7 +5668,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.
@@ -5684,7 +5687,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}`);
@@ -5776,7 +5779,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) {
@@ -6278,7 +6281,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'], ['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'], ['hide'], ['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/headless-harness.js

@@ -289,4 +289,25 @@ export function markHostOver(session, actorName, marks = 1) {
         throw new Error('markHostOver: this scene has no host');
     host.hostMarksBy.set(actorName, marks);
 }
+/**
+ * THE HOST HAS MADE THIS PERSONA -- test setup, not a game move.
+ *
+ * Since 2026-09-14 an alerted host hunts only what it has SPOTTED
+ * (models/host.ts `spotted`, utilities/ic.ts hostIsHunting); alert alone
+ * makes it look, every action. A fixture that wants the ice already on a
+ * persona states both facts here instead of hoping a Patrol roll lands.
+ */
+export function spotPersona(session, actorName) {
+    const scene = session.game.scene;
+    const actor = scene.getPlayerByName(actorName);
+    if (!actor)
+        throw new Error(`spotPersona: no actor called ${actorName}`);
+    const rooms = Object.values(scene.getRooms());
+    const here = actor.hostInside?.over.name;
+    const host = rooms.find(r => r.hasNode && r.name === here) ?? rooms.find(r => r.hasNode);
+    if (!host?.host)
+        throw new Error('spotPersona: this scene has no host');
+    host.host.alert = true;
+    host.host.spotted.add(actorName);
+}
 //# sourceMappingURL=headless-harness.js.map

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

@@ -45,8 +45,31 @@ export class Host {
      *  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. */
+    /** Walls up: the host knows it has an intruder (a blown Sleaze, a
+     *  successful Attack, a Patrol sighting) and its Patrol is looking
+     *  every action (Data Trails p.86). Never clears on its own -- canon
+     *  prints no stand-down. */
     alert = false;
+    /**
+     * PERSONAS THE HOST CAN SEE (2026-09-14, "constantly in combat" report).
+     *
+     * Alert and spotted are two different facts, and canon keeps them
+     * apart: a successful Attack action makes the target "aware that it is
+     * under attack ... but it doesn't automatically spot you" (p.236), while
+     * a blown Sleaze hands the target a free mark on you, which is being
+     * seen (p.236). A host and its IC share spotting (p.247), so one set on
+     * the host is every program's eyes. Ice hunts what the host can SEE
+     * (utilities/ic.ts hostIsHunting); an alerted host that cannot see you
+     * yet sweeps for you every action instead (ic.ts ambientPatrol, the
+     * focused branch). Cleared by a successful Hide (p.240) and by the
+     * persona's reboot (utilities/marks.ts clearMarksOn). Session-only.
+     */
+    spotted = new Set();
+    /** Personas that just Hid (p.240): the focused sweep lets ONE beat pass
+     *  before it looks again -- "the target must perform a new Matrix
+     *  Perception action", and the hide was this beat's action, not the
+     *  host's. Consumed by ic.ts ambientPatrol. Session-only. */
+    justHid = new Set();
     /** IC running now, by kind name. Names, not actors -- until increment 5. */
     runningIC = [];
     /** The running IC as actors, by kind (utilities/ic-actors.ts). Empty where no scene could host them. */

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/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

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

@@ -440,20 +440,20 @@ export function gridSculpt(actor, room) {
         const purpose = room.host?.purpose;
         const sculpt = room.host?.sculpt;
         return [
-            `{cyan-fg}INSIDE :: ${hostLabel(room, { capital: true }).toUpperCase()} [HR ${room.hostRating}]${purpose ? ` -- ${purpose}` : ''}{/cyan-fg}`,
-            `{cyan-fg}${sculpt ?? 'Architecture all the way around -- the outside grid is a wall away and might as well be weather.'}{/cyan-fg}`,
+            `{lightblue-fg}INSIDE :: ${hostLabel(room, { capital: true }).toUpperCase()} [HR ${room.hostRating}]${purpose ? ` -- ${purpose}` : ''}{/lightblue-fg}`,
+            `{lightblue-fg}${sculpt ?? 'Architecture all the way around -- the outside grid is a wall away and might as well be weather.'}{/lightblue-fg}`,
         ].join('\n');
     }
     // ON THE GRID (SR5 pp.217-218): no street under the persona -- a black
     // flatland, the body's room named only because that is where the
     // signal comes from. A host directly overhead gets a line of its own.
     const body = actor.bodyRoom ?? room;
-    const header = `{cyan-fg}THE GRID :: jacked in from ${body.name.toUpperCase()}{/cyan-fg}`;
+    const header = `{lightblue-fg}THE GRID :: jacked in from ${body.name.toUpperCase()}{/lightblue-fg}`;
     const grid = actor.currentGrid;
-    const flat = `{cyan-fg}Black flatland under a black sky -- the icons are the only things out here.${grid ? ` Riding ${grid.name}${grid.userPenalty ? ' (-2 on everything you do, p.233)' : ''}.` : ''}{/cyan-fg}`;
+    const flat = `{lightblue-fg}Black flatland under a black sky -- the icons are the only things out here.${grid ? ` Riding ${grid.name}${grid.userPenalty ? ' (-2 on everything you do, p.233)' : ''}.` : ''}{/lightblue-fg}`;
     if (!room.hasNode)
         return `${header}\n${flat}`;
-    return `${header}\n${flat}\n{cyan-fg}${hostLabel(room, { capital: true })} hangs directly overhead, sealed. What it holds is inside it.{/cyan-fg}`;
+    return `${header}\n${flat}\n{lightblue-fg}${hostLabel(room, { capital: true })} hangs directly overhead, sealed. What it holds is inside it.{/lightblue-fg}`;
 }
 /**
  * The icons rendered as the standard cyan block, or the thin-grid line.
@@ -482,19 +482,19 @@ export function gridIconBlock(scene, actor, room, rooms) {
     if (actor.insideHost || !rooms) {
         const icons = gridIcons(scene, actor, room);
         if (icons.length === 0) {
-            return `{cyan-fg}Thin grid out here -- background noise, nothing worth cracking.{/cyan-fg}`;
+            return `{lightblue-fg}Thin grid out here -- background noise, nothing worth cracking.{/lightblue-fg}`;
         }
-        return `{cyan-fg}ICONS IN REACH:{/cyan-fg}\n${icons.map(i => `  {cyan-fg}${i}{/cyan-fg}`).join('\n')}`;
+        return `{lightblue-fg}ICONS IN REACH:{/lightblue-fg}\n${icons.map(i => `  {lightblue-fg}${i}{/lightblue-fg}`).join('\n')}`;
     }
     const out = [];
     const hosts = hostsInReach(rooms, actor);
     out.push(hosts.length > 0
-        ? `{cyan-fg}HOSTS OVERHEAD:{/cyan-fg}\n${hosts.map(h => `  {cyan-fg}${hostLine(h, actor)}{/cyan-fg}`).join('\n')}`
-        : `{cyan-fg}Nothing overhead -- no host stands over this district.{/cyan-fg}`);
+        ? `{lightblue-fg}HOSTS OVERHEAD:{/lightblue-fg}\n${hosts.map(h => `  {lightblue-fg}${hostLine(h, actor)}{/lightblue-fg}`).join('\n')}`
+        : `{lightblue-fg}Nothing overhead -- no host stands over this district.{/lightblue-fg}`);
     const near = gridIcons(scene, actor, gridVicinity(actor)).filter(i => !isHostLine(i));
     out.push(near.length > 0
-        ? `{cyan-fg}ICONS IN REACH:{/cyan-fg}\n${near.map(i => `  {cyan-fg}${i}{/cyan-fg}`).join('\n')}`
-        : `{cyan-fg}Nothing near -- background noise around your signal.{/cyan-fg}`);
+        ? `{lightblue-fg}ICONS IN REACH:{/lightblue-fg}\n${near.map(i => `  {lightblue-fg}${i}{/lightblue-fg}`).join('\n')}`
+        : `{lightblue-fg}Nothing near -- background noise around your signal.{/lightblue-fg}`);
     // FARTHER OUT, WITHOUT AN ADDRESS (SR5 p.235, p.243): Matrix Perception
     // never tells you where a device physically sits -- that is Trace Icon,
     // two marks and an opposed test. So far icons are listed by the noise
@@ -519,9 +519,9 @@ export function gridIconBlock(scene, actor, room, rooms) {
         byBand.set(noise, list);
     }
     const far = [...byBand.entries()].sort((a, b) => a[0] - b[0])
-        .map(([noise, names]) => `  {cyan-fg}· dim, noise -${noise}: ${names.join(', ')}{/cyan-fg}`);
+        .map(([noise, names]) => `  {lightblue-fg}· dim, noise -${noise}: ${names.join(', ')}{/lightblue-fg}`);
     if (far.length > 0)
-        out.push(`{cyan-fg}FARTHER OUT -- dimmer with distance:{/cyan-fg}\n${far.join('\n')}`);
+        out.push(`{lightblue-fg}FARTHER OUT -- dimmer with distance:{/lightblue-fg}\n${far.join('\n')}`);
     // A blank line between the distance bands (user, 2026-09-02): three
     // sections read as three when they do not touch.
     return out.join('\n\n');
@@ -536,7 +536,7 @@ export function gridIconBlock(scene, actor, room, rooms) {
  * the other personas, and the files. Cut to the dock's rows and columns.
  */
 export function hostInteriorPanel(scene, actor, host, rows, cols) {
-    const cut = (raw) => `{cyan-fg}${[...raw].slice(0, Math.max(4, cols)).join('')}{/cyan-fg}`;
+    const cut = (raw) => `{lightblue-fg}${[...raw].slice(0, Math.max(4, cols)).join('')}{/lightblue-fg}`;
     const lines = [];
     lines.push(cut(`INSIDE ${host.name}`));
     if (host.purpose)

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

@@ -55,8 +55,12 @@ export async function hostTurnStart(scene, host, enc) {
  *  inside it -- even with every program crashed, the host gets its next
  *  turn to relaunch (p.355-356). */
 export function hostKeepsFighting(scene, host) {
+    // ...and someone it can SEE (Host.spotted, 2026-09-14). A persona that
+    // Hides (p.240) is still inside and the host is still alert, but with
+    // nobody in view the ice has nothing to swing at: the fight closes and
+    // the focused Patrol sweep (ic.ts ambientPatrol) takes over.
     return host.alert && !host.sanctioned
-        && personasInside(scene, host).some(p => scene.isHumanControlled(p) && !p.isIncapacitated());
+        && personasInside(scene, host).some(p => scene.isHumanControlled(p) && !p.isIncapacitated() && host.spotted.has(p.name));
 }
 /**
  * OPEN THE HOST'S FIGHT on an intruder it has made. The aggressor is a

package/bundle/typescript/src/commands/game/sideQuest/utilities/ic-brain.js

@@ -1,6 +1,7 @@
-import { IC_TYPES, icActs } from './ic.js';
+import { IC_TYPES, icActs, isSpotted, patrolPerception, spot } from './ic.js';
 import { leaveMatrix } from './planes.js';
 import { Logger } from './logger.js';
+import { personasInside } from './matrix-roster.js';
 /**
  * A PROGRAM'S ACTION PHASE (SR5 p.247): one Complex Action, by rule.
  *
@@ -25,6 +26,34 @@ export async function runIcActionPhase(enc, ice) {
     const budget = enc.budgetOf(ice);
     if (!budget)
         return;
+    // PATROL'S PHASE IS A SEARCH, NOT A SWING (p.248; Data Trails p.86: a
+    // suspicious Patrol runs Matrix Perception every action). It spends its
+    // Complex on the personas the host has NOT found yet -- a hidden one,
+    // a silent newcomer -- and a hit hands them to every other program.
+    if (type.kind === 'patrol') {
+        const out = { lines: [], meta: [], world: [] };
+        const unseen = personasInside(enc.scene, host)
+            .filter(p => enc.scene.isHumanControlled(p) && !isSpotted(host.over, p));
+        for (const p of unseen) {
+            if (patrolPerception(host.over, p, out)) {
+                spot(host.over, p);
+                if (!enc.has(p))
+                    enc.join(p);
+                out.lines.push(`  {red-fg}Patrol IC finds ${p.name}'s icon in the traffic -- the host has them now.{/red-fg}`);
+                out.world.push(`${host.name}'s Patrol IC found ${p.name}.`);
+            }
+            else {
+                out.lines.push(`  Patrol IC quarters the datastream for ${p.name} and comes up empty -- this pass.`);
+            }
+        }
+        if (unseen.length === 0)
+            out.lines.push(`  Patrol IC keeps every icon it can see in view and hands each move to the host.`);
+        budget.spend('complex', type.name);
+        for (const w of out.world)
+            enc.scene.addWorldEvent(w);
+        await enc.announce(out.lines, out.meta);
+        return;
+    }
     const target = pickTarget(enc, ice);
     if (!target) {
         logger.write(`Ice: ${ice.name} has nobody in the host to hunt -- phase forfeited.`);
@@ -66,7 +95,11 @@ export async function runIcActionPhase(enc, ice) {
  * read), then whoever it last engaged, then the first enemy standing.
  */
 function pickTarget(enc, ice) {
-    const enemies = enc.enemiesOf(ice).filter(e => e.plane === 'matrix');
+    // Only what the host can SEE (Host.spotted, shared by all its IC,
+    // p.247): a persona that Hid is still a participant until the fight
+    // notices nobody is left in view, and nothing may swing at it meanwhile.
+    const over = ice.icHost?.over;
+    const enemies = enc.enemiesOf(ice).filter(e => e.plane === 'matrix' && (!over || isSpotted(over, e)));
     if (enemies.length === 0)
         return undefined;
     const marksOn = ice.icHost?.marksOn;

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

@@ -140,6 +140,21 @@ const empty = () => ({ lines: [], meta: [], world: [] });
  * maglocks fall, the vault unseals -- but it stops being an immunity.
  */
 export function hostIsHunting(room, actor) {
+    return hostSuspectsOrHunts(room, actor)
+        // ...AND IT CAN SEE YOU (2026-09-14, "constantly in combat, even
+        // running silent"). Alert used to be the whole test, so a host woken
+        // by a successful Brute Force -- which canon says leaves it "aware
+        // that it is under attack ... but it doesn't automatically spot you"
+        // (p.236) -- opened the fight on the next keystroke and the silent
+        // test in ambientPatrol was never rolled (it bailed on alert). Ice
+        // hunts what the host has SPOTTED (Host.spotted, shared with every
+        // program, p.247); an alerted host that has not spotted you sweeps
+        // for you every action instead (ambientPatrol, focused).
+        && isSpotted(room, actor);
+}
+/** Alert, inside, unsanctioned -- the host is looking, whether or not it
+ *  has found this persona yet. The two halves below split on that. */
+function hostSuspectsOrHunts(room, actor) {
     return actor.plane === 'matrix'
         && room.hasNode
         // IC RUNS INSIDE THE HOST, AND NOWHERE ELSE (p.246-247; Deditri,
@@ -161,6 +176,27 @@ export function hostIsHunting(room, actor) {
         && !room.hostSanctioned
         && room.hostAlert;
 }
+/** An alerted host that has NOT found this persona: its Patrol is
+ *  running Matrix Perception every action (Data Trails p.86). */
+export function hostSuspects(room, actor) {
+    return hostSuspectsOrHunts(room, actor) && !isSpotted(room, actor);
+}
+/** Has this host (and so all its IC, p.247) got eyes on the persona? */
+export function isSpotted(room, actor) {
+    return room.host?.spotted.has(actor.name) ?? false;
+}
+/**
+ * THE HOST SEES YOU. One door for every way of being made -- a blown
+ * Sleaze's free mark (p.236), a Patrol sighting, Probe's grip -- so the
+ * fact that alert and spotted are two things is written in one place.
+ */
+export function spot(room, actor) {
+    const host = room.host;
+    if (!host)
+        return;
+    host.alert = true;
+    host.spotted.add(actor.name);
+}
 /**
  * IS THIS PERSONA A LEGITIMATE USER? (p.248, Patrol.)
  *
@@ -234,39 +270,46 @@ export function ambientPatrol(room, actor) {
     // back, it is not watching for you. See hostIsHunting.
     if (room.hostSanctioned)
         return out;
-    // Already made: the alerted host's own turn owns that persona
-    // (runHostTurn dispatches there instead). A CRACKED host is no longer
-    // exempt -- see hostIsHunting for why that ruling was retired.
-    if (room.hostAlert)
-        return out;
-    if (looksLegitimate(room, actor))
+    // Already SEEN: the alerted host's ice owns that persona (hostIsHunting
+    // -> the host arena's Combat Turn). A CRACKED host is no longer exempt
+    // -- see hostIsHunting for why that ruling was retired.
+    if (isSpotted(room, actor))
         return out;
-    // The sweep is on a clock (Data Trails p.86) -- it is not looking
-    // every single moment until it has reason to.
-    const due = (room.patrolCountdown ?? rollPatrolInterval(room.hostRating)) - 1;
-    if (due > 0) {
-        room.patrolCountdown = due;
+    // TWO CADENCES, AND THE HOST'S ALERT PICKS BETWEEN THEM (Data Trails
+    // p.86, the "constantly in combat" report of 2026-09-14). An
+    // unsuspecting host sweeps on the rating interval and lets a marked
+    // user be (p.248). A host that KNOWS it has an intruder -- a Brute
+    // Force it felt, a Sleaze it caught, a sighting -- runs Matrix
+    // Perception "every action", and it is not reassured by a mark: host
+    // security stays "vigilant for unauthorized users, even those with
+    // marks" (DT p.168-169), and the mark a Brute Force just planted is
+    // exactly what it is looking at. This used to return early on alert
+    // instead, which is why running silent never got its roll.
+    const focused = room.hostAlert;
+    // A persona that Hid THIS beat is not re-swept on the same beat: the
+    // hide was its action; the host's new perception is its own (p.240).
+    if (focused && room.host?.justHid.delete(actor.name))
         return out;
+    if (!focused) {
+        if (looksLegitimate(room, actor))
+            return out;
+        // The sweep is on a clock (Data Trails p.86) -- it is not looking
+        // every single moment until it has reason to.
+        const due = (room.patrolCountdown ?? rollPatrolInterval(room.hostRating)) - 1;
+        if (due > 0) {
+            room.patrolCountdown = due;
+            return out;
+        }
+        room.patrolCountdown = rollPatrolInterval(room.hostRating);
     }
-    room.patrolCountdown = rollPatrolInterval(room.hostRating);
-    let spotted;
-    if (!actor.runningSilent) {
-        // p.235: no test. A visible icon in the host is simply seen.
-        spotted = true;
-        out.meta.push(`Patrol IC -- sweep: icon not running silent, spotted automatically (no test, p.235)`);
-    }
-    else {
-        const look = rollPool(room.hostRating * 2, room.hostAttributes().dataProcessing);
-        const hide = rollPool(actor.logic + actor.matrixAttribute('sleaze'));
-        // p.236: a tie goes to the hider.
-        spotted = look.hits > hide.hits;
-        out.meta.push(`Patrol IC -- Matrix Perception (Host Rating x2 [Data Processing]): ${formatRoll(look)} v. Logic + Sleaze: ${formatRoll(hide)}`);
-    }
+    const spotted = patrolPerception(room, actor, out);
     if (!spotted) {
-        out.lines.push(`  Something quarters the datastream around you and moves on. Your silence held.`);
+        out.lines.push(focused
+            ? `  Patrol IC is HUNTING -- it quarters the datastream around you, hard, and slides past. Your silence held. For now.`
+            : `  Something quarters the datastream around you and moves on. Your silence held.`);
         return out;
     }
-    room.hostAlert = true;
+    spot(room, actor);
     actor.sneaking = false;
     // NAME THE HOST THAT FOUND YOU (rG8LtMoy5DHQJ2NuG: "I got a
     // notification that an IC has found me, however I haven't entered a
@@ -282,10 +325,32 @@ export function ambientPatrol(room, actor) {
     // So it says WHICH host, and where it is. That is the whole fix; the
     // deeper problem -- that this engine has no inside-vs-outside-host
     // state for the player to have crossed -- is its own item.
-    out.lines.push(`  {red-fg}${hostLabel(room, { capital: true })} makes you -- an unmarked icon where none should be. You're inside its architecture, on ${room.name}'s patch of grid, and it knows it has an intruder.{/red-fg}`);
-    out.world.push(`${room.name}'s Patrol IC made ${actor.name} on a routine sweep -- alarm flagged, ice hunting.`);
+    out.lines.push(focused
+        ? `  {red-fg}${hostLabel(room, { capital: true })} makes you -- the hunting Patrol locks onto your icon and every program in the architecture has you now.{/red-fg}`
+        : `  {red-fg}${hostLabel(room, { capital: true })} makes you -- an unmarked icon where none should be. You're inside its architecture, on ${room.name}'s patch of grid, and it knows it has an intruder.{/red-fg}`);
+    out.world.push(focused
+        ? `${room.name}'s hunting Patrol IC found ${actor.name} -- ice closing.`
+        : `${room.name}'s Patrol IC made ${actor.name} on a routine sweep -- alarm flagged, ice hunting.`);
     return out;
 }
+/**
+ * ONE MATRIX PERCEPTION BY THE HOST'S PATROL against one persona, the
+ * dice canon prints and nothing more: a non-silent icon is seen with no
+ * test (p.235); a silent one is an Opposed Test, Host Rating x2 [Data
+ * Processing] (the IC pool, p.247; the perception bracket, p.241) v.
+ * Logic + Sleaze, and a tie goes to the hider (p.236). Returns whether
+ * the persona was seen; the caller decides what that costs.
+ */
+export function patrolPerception(room, actor, out) {
+    if (!actor.runningSilent) {
+        out.meta.push(`Patrol IC -- sweep: icon not running silent, spotted automatically (no test, p.235)`);
+        return true;
+    }
+    const look = rollPool(room.hostRating * 2, room.hostAttributes().dataProcessing);
+    const hide = rollPool(actor.logic + actor.matrixAttribute('sleaze'));
+    out.meta.push(`Patrol IC -- Matrix Perception (Host Rating x2 [Data Processing]): ${formatRoll(look)} v. Logic + Sleaze: ${formatRoll(hide)}`);
+    return look.hits > hide.hits;
+}
 /**
  * THE HOST'S WHOLE TURN: its eyes if it has not made you, its ice if it
  * has. One entry point, so the caller never has to know which half of
@@ -618,11 +683,17 @@ function dealBiofeedback(actor, dv, type, out) {
  * pre-alert patrolling exists, the interval table is what it needs.
  */
 function patrolActs(room, actor, out) {
-    // No Attack rating means no bracket to cap the hits with.
-    const roll = rollPool(room.hostRating * 2);
-    out.meta.push(`Patrol IC -- Matrix Perception (Host Rating x2): ${formatRoll(roll)}`);
-    if (roll.hits > 0) {
-        out.lines.push(`  {red-fg}Patrol IC sweeps your icon and hands what it sees to the host.{/red-fg}`);
+    // A persona the host can already see (which is what this composition
+    // is handed) gets no second roll -- Patrol's perception is the one in
+    // patrolPerception, spent on personas it has NOT found (ic-brain.ts
+    // runs it against each unspotted icon inside during the fight).
+    if (isSpotted(room, actor)) {
+        out.lines.push(`  {red-fg}Patrol IC keeps your icon in view and hands every move to the host.{/red-fg}`);
+        return;
+    }
+    if (patrolPerception(room, actor, out)) {
+        spot(room, actor);
+        out.lines.push(`  {red-fg}Patrol IC sweeps your icon and hands what it sees to the host -- it has you now.{/red-fg}`);
     }
     else {
         // "Does not take Matrix damage when it fails" -- a whiff costs it
@@ -659,6 +730,8 @@ function probeActs(room, actor, type, out, ice) {
     }
     const now = held + 1;
     room.hostMarksOn.set(actor.name, now);
+    // A grip is a sighting: the host and every program see what Probe holds.
+    spot(room, actor);
     out.lines.push(`  {red-fg}Probe IC gets a grip -- the host holds ${now} mark${now === 1 ? '' : 's'} on you now${now >= MAX_MARKS ? ', all it can carry' : ''}.{/red-fg}`);
     out.world.push(`${room.name}'s ice tightened its hold on ${actor.name}.`);
 }

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

@@ -44,6 +44,9 @@ export function clearMarksOn(actor, scene) {
             if ((room.host?.marksOn.get(actor.name) ?? 0) > 0)
                 had++;
             room.host?.marksOn.delete(actor.name);
+            // A rebooted persona is a fresh icon: whatever the host had SPOTTED
+            // is gone with the marks (Host.spotted) -- it has to find you again.
+            room.host?.spotted.delete(actor.name);
         }
     }
     return had;

package/bundle/typescript/src/commands/game/sideQuest/utilities/matrix-style.js

@@ -0,0 +1,8 @@
+export const MATRIX_COLOR = 'lightblue';
+export const FEED_COLOR = 'white';
+export const TURN_COLOR = 'yellow';
+/** Matrix-plane prose, tagged. */
+export function mx(text) {
+    return `{${MATRIX_COLOR}-fg}${text}{/${MATRIX_COLOR}-fg}`;
+}
+//# sourceMappingURL=matrix-style.js.map

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

@@ -58,10 +58,10 @@ export function accrueOverwatch(scene, actor, defenseHits, why) {
     // The grid's built-in warning system (p.221): subtle ripples, once
     // per band -- the only free hint the player ever gets.
     if (before < 30 && actor.overwatchScore >= 30) {
-        return { lines: [`{cyan-fg}The grid RIPPLES -- hard, close, and looking. Something vast has nearly found the thread you're hanging by. ("reboot" is a clean slate.){/cyan-fg}`], converged: false };
+        return { lines: [`{lightblue-fg}The grid RIPPLES -- hard, close, and looking. Something vast has nearly found the thread you're hanging by. ("reboot" is a clean slate.){/lightblue-fg}`], converged: false };
     }
     if (before < 20 && actor.overwatchScore >= 20) {
-        return { lines: [`{cyan-fg}A ripple crosses the grid -- subtle, wrong, deliberate. Somewhere above, an eye has started counting your fingerprints.{/cyan-fg}`], converged: false };
+        return { lines: [`{lightblue-fg}A ripple crosses the grid -- subtle, wrong, deliberate. Somewhere above, an eye has started counting your fingerprints.{/lightblue-fg}`], converged: false };
     }
     return { lines: [], converged: false };
 }

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

@@ -107,7 +107,7 @@ export function enterMatrix(scene, actor, mode) {
     // half-done, which would be a fresh canon violation wearing a
     // feature's clothes. See the PR for CgJ6uTfEvTd8JXdDN.
     actor.activeDeck = actor.isTechnomancer() ? undefined : actor.getCyberdeck();
-    actor.performAction('jacks in', `slumping where they stand, eyes flickering (${mode}-sim)`);
+    actor.performAction('jacks in', `slumping where they stand, eyes flickering (${mode}-sim)`, { quiet: scene.isHumanControlled?.(actor) ?? false });
     scene.addWorldEvent(`${actor.name} jacked into the Matrix in ${actor.bodyRoom.name}.`);
     Logger.getInstance().write(`${actor.name} entered the Matrix (${mode}-sim, ${actor.activeDeck?.name ?? (actor.isTechnomancer() ? 'living persona' : 'no deck?!')}) from ${actor.bodyRoom.name}.`);
     const hotWarning = mode === 'hot'
@@ -267,7 +267,7 @@ export function leaveMatrix(scene, actor, opts) {
         actor.bodyRoom = undefined;
         lines.push(`You're back in your body in ${body.name}.`);
     }
-    actor.performAction('jacks out', 'stirring awake');
+    actor.performAction('jacks out', 'stirring awake', { quiet: scene.isHumanControlled?.(actor) ?? false });
     scene.addWorldEvent(`${actor.name} jacked out of the Matrix.`);
     scene.updateStatus();
     return lines;
@@ -449,7 +449,7 @@ export function fileReach(actor, room) {
  */
 export function planeTintItemName(item, viewerPlane) {
     if (item.plane === 'matrix') {
-        return `{cyan-fg}${item.name} [data]{/cyan-fg}`;
+        return `{lightblue-fg}${item.name} [data]{/lightblue-fg}`;
     }
     if (item.plane === 'astral') {
         return `{magenta-fg}${item.name} [astral]{/magenta-fg}`;

package/bundle/typescript/src/commands/game/sideQuest/utilities/shared-run.js

@@ -24,6 +24,7 @@ import { join, dirname } from 'node:path';
 import { Logger } from './logger.js';
 import { hint } from './hints.js';
 import { CALL_ICON, CALL_COLOR, END_CALL_SENTINEL } from './comm-style.js';
+import { FEED_COLOR } from './matrix-style.js';
 import { ENGINE_VERSION } from '../engine-version.js';
 import { authToken, fetchSave } from './cloud-saves.js';
 import { saveSlug, restorePlayer, writeSaveAtomic } from './persistence.js';
@@ -1143,7 +1144,7 @@ export class SharedRunSession {
                     break;
                 }
                 for (const line of ev.text.split('\n'))
-                    g.logBox?.pushLine(`{cyan-fg}${line}{/cyan-fg}`);
+                    g.logBox?.pushLine(`{${FEED_COLOR}-fg}${line}{/${FEED_COLOR}-fg}`);
                 Logger.getInstance().transcript(ev.text);
                 g.followLog?.();
                 if (ev.kind === 'death' && ev.data?.player === g.player.name) {

package/package.json

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