@maka/maka-cli 5.184.0 → 5.185.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.184.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/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));

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

@@ -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.`);

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

@@ -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();

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();

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).
@@ -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/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/package.json

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