@maka/maka-cli 5.184.0 → 5.186.0

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

@@ -9,7 +9,9 @@ import { hostLabel } from './utilities/grid-names.js';
 import { marksPlaced, marksOnYou } from './utilities/marks.js';
 import { settleUnresolvedHarm } from './utilities/harm-settlement.js';
 import { hostInteriorPanel } from './utilities/grid-view.js';
-import { DEFAULT_GRID_PROVIDER, PUBLIC_GRID, globalGrid } from './utilities/grids.js';
+import { DEFAULT_GRID_PROVIDER, PUBLIC_GRID, globalGrid, looseEndGrid } from './utilities/grids.js';
+import { buildCleanupSeed } from './factories/cleanup-seed.js';
+import { EditFileCommand, EraseCommand } from './commands/edit-file.js';
 import { hostsInReach, hostDockLine, gridVicinity } from './utilities/grid-reach.js';
 import { nameThem, scrubHandles } from './utilities/identity.js';
 import { dirname } from 'path';
@@ -149,7 +151,7 @@ import { MoveCommand, RunCommand, SprintCommand } from './commands/move.js';
 import { ClimbCommand, DescendCommand } from './commands/climb.js';
 import { HintsCommand } from './commands/hints.js';
 import { hint } from './utilities/hints.js';
-import { camerasLive } from './utilities/surveillance.js';
+import { camerasLive, liveFootage } from './utilities/surveillance.js';
 import { InstallCommand } from './commands/install.js';
 import { BuyCommand } from './commands/buy.js';
 import { SellCommand } from './commands/sell.js';
@@ -177,6 +179,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';
@@ -522,6 +525,192 @@ export default class Game {
         this._runHeat += billed;
         Logger.getInstance().write(`Heat: +${billed}${billed !== amount ? ` (${amount} doubled on camera)` : ''} (${why}) -> ${this._runHeat}.`);
     }
+    // ==================== LOOSE ENDS (2026-09-14) ====================
+    // What a run leaves behind that the runner can still go back and fix.
+    // The camera line above promised "that footage is already somewhere
+    // else" and nothing modelled where: a run ended, _camSeenRooms was
+    // cleared, and the promise evaporated. Now a run that ends with the
+    // feeds still live on an uncracked host leaves an ILooseEnd on the
+    // save; from the hub a Matrix-capable runner jacks in, "hop"s onto
+    // the site's grid (utilities/grids.ts looseEndGrid) and erases the
+    // file (commands/edit-file.ts) in a one-host scene entered and left
+    // through the Matrix alone (enterCleanup / onPersonaLeftMatrix). Left
+    // for LOOSE_END_GRACE full homecomings, the desk reviews the feeds and
+    // it converts to Public Awareness (p.368, "leaving significant
+    // physical evidence"). Infinity here is the "no consequence" switch.
+    _looseEnds = [];
+    static LOOSE_END_GRACE = 1;
+    /** The cleanup in progress: which record, where the body is slumped,
+     *  the Matrix companions carried across, and the hub to hand back. */
+    _cleanup;
+    get looseEnds() {
+        return this._looseEnds ?? [];
+    }
+    get inCleanup() {
+        return this._cleanup !== undefined;
+    }
+    /**
+     * THE FOOTAGE THIS RUN LEAVES BEHIND, read BEFORE the scene swap that
+     * discards the run (returnToHub), or off the live handle by the site
+     * before dispose (run-summary.ts). Undefined when no camera saw
+     * anything, when the feeds died before the end (host cracked, cluster
+     * looped or bricked), or when there is no host to hold them.
+     */
+    footageLeft() {
+        if (!this.onRun || this.sceneSeed?.cleanup)
+            return undefined;
+        const found = liveFootage(this.scene.getRooms(), this._camSeenRooms);
+        if (!found)
+            return undefined;
+        const host = found.host;
+        const site = host.name;
+        return {
+            id: `${site.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')}-${Date.now()}`,
+            kind: 'footage',
+            jobName: this.currentJobName ?? 'a job',
+            site,
+            host: { room: host.name, rating: host.hostRating, purpose: host.host?.purpose, sculpt: host.host?.sculpt },
+            rooms: found.rooms.map(r => r.name),
+            capturedAt: new Date().toISOString(),
+            homecomingsLeft: Game.LOOSE_END_GRACE,
+        };
+    }
+    /**
+     * EVERY FULL HOMECOMING (returnToHub, applyHostedHomecoming): the open
+     * records lose a grace point; expired ones become the Public Awareness
+     * incident they were always going to be; tonight's fresh one is
+     * appended untouched. A cleanup's own exit never comes through here.
+     */
+    settleLooseEnds(fresh) {
+        const lines = [];
+        const kept = [];
+        // `?? []`: hosted-homecoming.test.ts drives a Game off its prototype,
+        // where field initialisers never ran.
+        for (const le of this._looseEnds ?? []) {
+            const left = le.homecomingsLeft - 1;
+            if (left > 0) {
+                kept.push({ ...le, homecomingsLeft: left });
+                continue;
+            }
+            const stained = this.player.addPublicAwareness(`caught on the cameras at "${le.site}" during "${le.jobName}"`);
+            Logger.getInstance().write(`Loose end "${le.id}" expired: ${le.site}'s desk reviewed the feeds (awareness ${stained ? '+1' : 'already counted'}).`);
+            lines.push(`\n{red-fg}${le.site}'s security desk finally reviews the night's feeds from "${le.jobName}". A still of your face goes out on the district's channels.{/red-fg}${stained ? ` (+1 Public Awareness, now ${this.player.publicAwareness})` : ''}`);
+        }
+        this._looseEnds = kept;
+        if (fresh) {
+            this._looseEnds.push(fresh);
+            Logger.getInstance().write(`Loose end "${fresh.id}" left: ${fresh.site} kept footage of "${fresh.jobName}" (${fresh.rooms.join(', ')}).`);
+            lines.push(`\n{yellow-fg}A camera at ${fresh.site} still has your face from tonight -- the footage sits on the site's own host, unreviewed.{/yellow-fg}${hint(` ("jack in", then "hop ${fresh.site}" -- erase it before the desk finds it.)`)}`);
+        }
+        return lines;
+    }
+    /** The grids "hop" lists for the open loose ends -- from the hub only. */
+    looseEndGrids() {
+        if (!this.hasHub || this.scene !== this._hubScene)
+            return [];
+        return this._looseEnds.map(le => ({ grid: looseEndGrid(le), looseEnd: le }));
+    }
+    /**
+     * THE HOP LANDS (commands/hop.ts): the persona is on the site's grid,
+     * so the site's host is what hangs overhead now. The body never
+     * moves -- its hub room joins the cleanup scene so the persona has a
+     * vicinity (grid-reach.ts) and the jack-out has somewhere to wake up
+     * -- and nothing that a job's arrival does happens here: no crew at
+     * the curb, no departure needs, no companion fold, no meet. The seed
+     * is deterministic (factories/cleanup-seed.ts) and disposable: it is
+     * rebuilt on every hop and dropped on every jack-out.
+     */
+    async enterCleanup(grid) {
+        const hub = this._hubScene;
+        const entry = this.looseEndGrids().find(g => g.grid.key === grid.key);
+        if (!hub || !entry || this._cleanup)
+            return [];
+        const le = entry.looseEnd;
+        const body = this.player.bodyRoom ?? this.player.currentLocation;
+        const seed = buildCleanupSeed(le, this.player.name);
+        const scene = await SceneSynthesizer.synthesizeFromJson(seed, this.player, false, false);
+        scene.localGrid = grid;
+        scene.addRoom(body);
+        scene.adopt(this);
+        const carried = this.carryPersonasAcross(hub, scene, body);
+        this._cleanup = { id: le.id, body, carried, hub };
+        this.sceneSeed = seed;
+        this.scene = scene;
+        this.resolveHostGrids();
+        // Cold, like any run: the cleanup's own heat is the Matrix's price
+        // (Overwatch, convergence) and is dropped on the way out.
+        this._runHeat = 0;
+        this._camSeenRooms.clear();
+        this.camPingedRooms.clear();
+        this.sweptRooms.clear();
+        this.runStartedAt = worldNow();
+        this.currentClient = undefined;
+        this.forfeitArmed = false;
+        this.repaintForScene();
+        this.refreshLogLabel();
+        this.onSceneChanged?.();
+        Logger.getInstance().write(`Loose end "${le.id}" entered: ${seed.name} (host ${le.host.room} HR ${le.host.rating}, body in ${body.name}).`);
+        return [
+            `\n${scene.story}`,
+            hint(`("hack" the host, "enter" it, "search" its archive, then "erase" the file. "jack out" is the only way home.)`),
+        ];
+    }
+    /** Sprites and agents ride with the persona; drones and meat companions
+     *  stay wherever the body is. Reversed by leaveCleanup. */
+    carryPersonasAcross(from, to, body) {
+        const moved = [];
+        for (const c of this.companions) {
+            if (c.npc.plane !== 'matrix')
+                continue;
+            from.removeActorQuietly(c.npc.name);
+            to.addActor(c.npc);
+            to.setCharacterLocation(c.npc, body.name);
+            moved.push(c.npc);
+        }
+        return moved;
+    }
+    /**
+     * EVERY WAY OUT OF THE MATRIX comes through planes.ts leaveMatrix, and
+     * this is the hook it calls: a clean jack-out, a torn link-lock, a
+     * bricked deck, Scramble, GOD's convergence. If a cleanup was live,
+     * the hub takes the scene back here.
+     */
+    onPersonaLeftMatrix(actor) {
+        if (!this._cleanup || actor !== this.player)
+            return [];
+        return this.leaveCleanup();
+    }
+    leaveCleanup() {
+        const c = this._cleanup;
+        const cleanup = this.scene;
+        const erased = cleanup.isCompleted();
+        const le = this._looseEnds.find(l => l.id === c.id);
+        if (erased)
+            this._looseEnds = this._looseEnds.filter(l => l.id !== c.id);
+        for (const npc of c.carried) {
+            cleanup.removeActorQuietly(npc.name);
+            c.hub.addActor(npc);
+            c.hub.setCharacterLocation(npc, c.body.name);
+        }
+        this._cleanup = undefined;
+        this.scene = c.hub;
+        this.sceneSeed = this._hubSeed ?? this.sceneSeed;
+        this.runStartedAt = undefined;
+        // No ride home, no checkpoint: the cleanup's heat is dropped. GOD's
+        // own stain (overwatch.ts addNotoriety) already landed if it did.
+        this._runHeat = 0;
+        this._camSeenRooms.clear();
+        this.camPingedRooms.clear();
+        this.sweptRooms.clear();
+        this.repaintForScene();
+        this.refreshLogLabel();
+        this.onSceneChanged?.();
+        Logger.getInstance().write(`Loose end "${c.id}" left: ${erased ? 'ERASED' : 'still open'}; hub is the scene again.`);
+        this.requestSave('cleanup');
+        return [erased
+                ? `\n{lightblue-fg}The grid closes behind you. ${le?.site ?? 'The site'}'s feeds run clean -- whatever they had of you is gone.{/lightblue-fg}`
+                : `\n{yellow-fg}The grid closes behind you. The footage is still up there.{/yellow-fg}${hint(` (Jack in and "hop" again while the desk hasn't reviewed it.)`)}`];
+    }
     /** The HUD's read on the district (bands, never the number). */
     heatBand() {
         if (this._runHeat <= 0)
@@ -2746,6 +2935,13 @@ ${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);
+        // Edit File (SR5 p.239): "edit delete <file>", and the delete form
+        // by its own names -- the loose-end cleanup's verb.
+        CommandFactory.registerCommand('edit', EditFileCommand);
+        CommandFactory.registerCommand('erase', EraseCommand);
+        CommandFactory.registerCommand('wipe', EraseCommand);
         // MAtrix Recognition Keys (canon p.235-236).
         CommandFactory.registerCommand('mark', MarkCommand);
         // Camera feeds you own (surveillance).
@@ -3131,7 +3327,10 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             const where = this._resumedAt && this._resumedAt !== this._homeRoom
                 ? `You're back at the ${this._resumedAt.name}${this.player.atSpot ? `, by the ${this.player.atSpot}` : ''} -- right where you left off.`
                 : 'The cot remembers your shape.';
-            return `Welcome back, ${this.player.name}. ${where}\n ${this.scene.story}${pendingNote}`;
+            const looseNote = this._looseEnds.length > 0
+                ? `\n\n{yellow-fg}${this._looseEnds.map(le => `${le.site} still has your face from "${le.jobName}".`).join(' ')}{/yellow-fg}${hint(` ("jack in", then "hop" -- the site's grid is listed while the footage is still up there.)`)}`
+                : '';
+            return `Welcome back, ${this.player.name}. ${where}\n ${this.scene.story}${pendingNote}${looseNote}`;
         }
         // Nudge the player toward "call" up front -- the fixer convention means
         // the story deliberately doesn't narrate a completed briefing, so
@@ -3255,6 +3454,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         applyHubOverlay(this.scene, save.hub, this.player, this._homeRoom);
         this._tier = save.game.tier;
         this._pendingHomecoming = save.game.pendingHomecoming;
+        this._looseEnds = (save.game.looseEnds ?? []).map(l => ({ ...l }));
         this.contacts = new Map(save.game.contacts);
         // Roles are DERIVED, not earned -- re-derive them all on every
         // resume so old saves self-heal (pre-role saves read all "Street
@@ -3572,6 +3772,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 })(),
                 crew: this.crew.map(m => ({ ...m, gear: [...m.gear] })),
                 pendingHomecoming: this._pendingHomecoming,
+                looseEnds: this._looseEnds.length > 0 ? this._looseEnds.map(l => ({ ...l })) : undefined,
                 commandRefusals: { ...this.commandRefusals },
                 fencedCategories: [...this.fencedCategories],
                 rumorIndex: this._rumorIndex,
@@ -3667,6 +3868,13 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // will carry a runner away from a job gone sideways (see call.ts) --
         // walking away just means the payout never landed. Classic sessions
         // skip this and keep the old continue->draft loop.
+        // A LOOSE-END CLEANUP IS NOT A RUN TO COME HOME FROM: there is no
+        // ride, and the homecoming ritual (rent, restock, the checkpoint)
+        // must not run over a scene the persona merely hopped into. The
+        // only door is the Matrix's (onPersonaLeftMatrix).
+        if (this._cleanup) {
+            return `You're jacked in on a loose end -- "jack out" is what ends it.`;
+        }
         if (this._hubScene && this.scene !== this._hubScene) {
             return this.returnToHub();
         }
@@ -3877,6 +4085,9 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // saying canon does not do that, and spending the consequence
         // somewhere the books actually put it.
         const loudRun = this.scene !== hub && this.scene.alarmRaised;
+        // THE FOOTAGE LEFT BEHIND (loose ends, 2026-09-14) -- read here for
+        // the same reason, before the run's rooms are gone.
+        const footage = this.scene !== hub ? this.footageLeft() : undefined;
         const awarenessLine = loudRun && this.player.addPublicAwareness(`left "${this.currentJobName ?? 'a job'}" screaming`)
             ? `\nYou left the place howling behind you. Somebody filed a report, somebody kept a still -- your face is a little more public than it was this morning. (+1 Public Awareness, now ${this.player.publicAwareness})`
             : '';
@@ -3972,6 +4183,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         const allyLine = crewLines.length > 0 ? `\n${crewLines.join('\n')}` : '';
         const docwagonLine = this.tickDocwagonHomecoming();
         const deliveryLine = this.deliverProcurements();
+        // Loose ends: last night's expire, tonight's is filed.
+        const looseEndLines = this.settleLooseEnds(footage);
         // The night catches up on the ride (SINs & getting caught): a hot
         // run means the wire between there and home. Settled AFTER the
         // payout (the fee comes out of tonight's take) and BEFORE the save
@@ -3984,7 +4197,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         const fateLine = wrappedRun
             ? `The run's wrapped and the street swallows you back up.`
             : `The run's behind you -- unfinished, unpaid, already someone else's problem. The street doesn't ask.`;
-        return `${checkpointBlock ? `\n${checkpointBlock}\n` : ''}\n${this._hubName.toUpperCase()}\n${fateLine} You're home -- your hideout, one door off ${hub.determineStartRoom().name}.${hint(` Call ${FIXER_NAME} when you're hungry for the next job.`)}${clientLine}${awarenessLine}\n${rentLine}${comfortLine}${restockLine}${deliveryLine}${docwagonLine}${allyLine}${companionBlock.length > 0 ? `\n${companionBlock.join('\n')}` : ''}`;
+        return `${checkpointBlock ? `\n${checkpointBlock}\n` : ''}\n${this._hubName.toUpperCase()}\n${fateLine} You're home -- your hideout, one door off ${hub.determineStartRoom().name}.${hint(` Call ${FIXER_NAME} when you're hungry for the next job.`)}${clientLine}${awarenessLine}${looseEndLines.join('')}\n${rentLine}${comfortLine}${restockLine}${deliveryLine}${docwagonLine}${allyLine}${companionBlock.length > 0 ? `\n${companionBlock.join('\n')}` : ''}`;
     }
     /** The rent, the slide, the tab, and the High-lifestyle shower --
      *  homecoming's money half, for the solo ride home and the hosted
@@ -4118,6 +4331,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         this.rollHireCandidates();
         const docwagonLine = this.tickDocwagonHomecoming();
         const deliveryLine = this.deliverProcurements();
+        const looseEndLines = this.settleLooseEnds(owed.footage);
         Logger.getInstance().write(`Hosted homecoming applied (${owed.outcome}, ended ${owed.endedAt}): rent ${this.rentDebt} owed, lifestyle ${this.lifestyleTier}.`);
         this.requestSave('homecoming');
         const fateLine = owed.outcome === 'wrapped'
@@ -4125,7 +4339,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             : owed.outcome === 'interrupted'
                 ? `The run was lost to the static -- the street doesn't ask.`
                 : `The run's behind you -- unfinished, unpaid, already someone else's problem. The street doesn't ask.`;
-        return `${fateLine} The table's settled; home takes its cut.${clientLine}${awarenessLine}\n${rentLine}${comfortLine}${restockLine}${deliveryLine}${docwagonLine}`;
+        return `${fateLine} The table's settled; home takes its cut.${clientLine}${awarenessLine}${looseEndLines.join('')}\n${rentLine}${comfortLine}${restockLine}${deliveryLine}${docwagonLine}`;
     }
     /**
      * KNIGHT ERRANT CHECKPOINT (SINs & getting caught, ruling 2026-08-24;
@@ -6278,7 +6492,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'], ['edit'], ['erase', 'wipe'], ['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/headless.js

@@ -609,6 +609,7 @@ export async function createHeadlessHub(opts) {
             save: (reason) => game.snapshotSave(reason),
             flush: (reason) => runInSession(ctx, () => game.flushBoundSave(reason)),
             inRun: () => !game.onHubScene,
+            inSession: fn => runInSession(ctx, fn),
         };
     });
 }

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

@@ -104,6 +104,19 @@ export class Scene extends AbstractScene {
         this.addActor(this.player);
         this.game = game;
     }
+    /**
+     * ADOPT A PLAYER WHOSE BODY DOES NOT MOVE (Game.enterCleanup, 2026-09-14).
+     * initialize() seats the player at the seed's start room, which for a
+     * run is the arrival. A loose-end cleanup is entered from the Matrix:
+     * the body stays slumped wherever it jacked in (that room is added to
+     * this scene by the caller), so the seat must not change -- the
+     * currentLocation setter would clear the body's spot and fire a
+     * "move" save beat for a move that never happened.
+     */
+    adopt(game) {
+        this.addActor(this.player);
+        this.game = game;
+    }
     updateExits(room) {
         this.game.updateExits(room);
     }
@@ -979,6 +992,36 @@ export class Scene extends AbstractScene {
         this.logger.logWithColor(banner, 'green');
         return banner;
     }
+    /**
+     * THE ERASE OBJECTIVE (loose ends, 2026-09-14): met when the named file
+     * is DELETED by Edit File (commands/edit-file.ts) -- a state change on
+     * something you leave behind, which is why it is not a possession
+     * check. No payout ever: nobody hired the runner for this. Karma is a
+     * flat 1 -- a loose end tied off is worth a point (p.375's "survived"
+     * floor), and there is no stake to scale it by. Returns null when this
+     * is not the objective or it is already met.
+     */
+    checkErased(itemName, byName) {
+        const condition = this._winCondition;
+        if (!condition || this._completed || condition.type !== 'erase')
+            return null;
+        if (condition.item.toLowerCase() !== itemName.toLowerCase())
+            return null;
+        this._completed = true;
+        this.addWorldEvent(`${byName} erased ${itemName} -- the loose end is tied off.`);
+        this.logger.write(`Scene erase objective met: "${byName}" erased "${itemName}".`);
+        const karmaEarned = 1;
+        for (const p of this.players) {
+            if (this.deadPlayers.has(p.name))
+                continue;
+            p.karma += karmaEarned;
+            p.careerKarma += karmaEarned;
+        }
+        const karmaNote = `\nKarma earned: ${karmaEarned} (${this.player.karma} banked${hint(` -- "advance" at your hideout to train`)}).`;
+        const banner = `${condition.completionMessage}${karmaNote}\n\nLOOSE END TIED OFF\n${hint(`"jack out" when you're done here -- the grid closes behind you.`)}`;
+        this.logger.logWithColor(banner, 'green');
+        return banner;
+    }
     /**
      * Money actually landing in the runner's hands: accumulates on ONE
      * certified credstick across jobs (minting a same-named stick per job

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

@@ -57,11 +57,25 @@ export function hasAccess(lifestyleTier, district, target, provider = DEFAULT_GR
 export function hopDefenceDice(target) {
     return target.kind === 'public' ? 0 : target.kind === 'local' ? 4 : 6;
 }
+/**
+ * THE GRID A LOOSE END HANGS ON (Game.enterCleanup, 2026-09-14): the
+ * site whose cameras kept the runner's face runs its own local grid, and
+ * "hop" lists it while the record is open. Nobody's lifestyle buys
+ * access to it, so the hop is always the illegal one (p.240, Hack on the
+ * Fly v. 4 dice -- a local grid) -- exactly the rule hop.ts already
+ * implements, not a new gate. `kind: 'local'` is the same metroplex:
+ * canon lets you reach a local grid only from inside its service area
+ * (p.220-221), and the site is across town.
+ */
+export function looseEndGrid(le) {
+    return { key: `local:loose-end-${slug(le.id)}`, kind: 'local', name: `the ${le.site.trim()} site grid`, userPenalty: 0 };
+}
 /**
  * A grid by what a player types: "public", "local", the district's name,
- * a Big Ten name, or "global <corp>". Undefined when nothing answers.
+ * a Big Ten name, or "global <corp>" -- or one of `extras` (a loose end's
+ * site grid) by its site or full name. Undefined when nothing answers.
  */
-export function resolveGridName(query, district) {
+export function resolveGridName(query, district, extras = []) {
     const q = query.trim().toLowerCase().replace(/^the\s+/, '').replace(/\s+grid$/, '');
     if (q === '')
         return undefined;
@@ -69,6 +83,12 @@ export function resolveGridName(query, district) {
         return PUBLIC_GRID;
     if (q === 'local' || slug(q) === district.key.slice('local:'.length))
         return district;
+    const extra = extras.find(g => {
+        const name = g.name.toLowerCase().replace(/^the\s+/, '').replace(/\s+grid$/, '');
+        return slug(name) === slug(q) || slug(name.replace(/\s+site$/, '')) === slug(q);
+    });
+    if (extra)
+        return extra;
     const corpWord = q.replace(/^global\s+/, '');
     const corp = BIG_TEN.find(c => c.toLowerCase() === corpWord || slug(c) === slug(corpWord));
     return corp ? globalGrid(corp) : undefined;

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;