@maka/maka-cli 5.184.0 → 5.186.0

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

@@ -267,6 +267,11 @@ export function leaveMatrix(scene, actor, opts) {
         actor.bodyRoom = undefined;
         lines.push(`You're back in your body in ${body.name}.`);
     }
+    // A LOOSE-END CLEANUP ENDS HERE, whichever door the persona left by --
+    // a clean jack-out, a torn link-lock, a bricked deck, Scramble, GOD.
+    // Every exit is one of this function's callers, so this is the one
+    // place the hub takes the scene back (Game.onPersonaLeftMatrix).
+    lines.push(...(scene.ownerGame?.onPersonaLeftMatrix?.(actor) ?? []));
     actor.performAction('jacks out', 'stirring awake', { quiet: scene.isHumanControlled?.(actor) ?? false });
     scene.addWorldEvent(`${actor.name} jacked out of the Matrix.`);
     scene.updateStatus();

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

@@ -97,6 +97,40 @@ export function camerasLive(rooms, room) {
         return true;
     return !hosts.some(r => r.hostCracked);
 }
+/**
+ * WHAT THE CAMERAS STILL HOLD WHEN THE RUN ENDS (loose ends, 2026-09-14).
+ *
+ * `camSeen` is the set of rooms whose cameras were called out during the
+ * run (Game._camSeenRooms -- "a camera's dead eye caught ALL of it").
+ * The line promised the footage was "already somewhere else", and this
+ * is where: the host those cameras are slaved to. Footage survives the
+ * run when the room's feeds are STILL live at the end -- its master host
+ * never cracked, its cluster never looped or bricked -- and there is a
+ * host anywhere to hold it (standalone recorders keep nothing a decker
+ * could reach, so they leave no loose end). Grouped under one master
+ * (the one with the most rooms, then by name): one run, one record.
+ */
+export function liveFootage(rooms, camSeen) {
+    const byHost = new Map();
+    for (const name of camSeen) {
+        const room = Object.values(rooms).find(r => r.name === name);
+        if (!room || !camerasLive(rooms, room))
+            continue;
+        const master = cameraMasterHost(rooms, room);
+        if (!master)
+            continue;
+        const list = byHost.get(master) ?? [];
+        list.push(room);
+        byHost.set(master, list);
+    }
+    let best;
+    for (const [host, seen] of byHost) {
+        if (!best || seen.length > best.rooms.length || (seen.length === best.rooms.length && host.name.localeCompare(best.host.name) < 0)) {
+            best = { host, rooms: seen };
+        }
+    }
+    return best;
+}
 /** Can THIS persona watch the room's feeds remotely? Its own host
  *  cracked or marked; a hostless watched room answers to whoever owns
  *  any of the site's hosts. */

package/package.json

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