@maka/maka-cli 5.184.0 → 5.186.0

package/bundle/typescript/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.",

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

@@ -110,6 +110,12 @@ export class DownloadCommand extends Command {
         const fromSprite = carried.find(c => c.item.name === picked);
         const fromFar = !fromSprite && !loose.some(i => i.name === picked) ? far.find(f => f.item.name === picked) : undefined;
         const item = fromSprite ? fromSprite.item : fromFar ? fromFar.item : loose.find(i => i.name === picked);
+        // A LOOSE END IS ERASED, NOT DOWNLOADED (take.ts has the same gate):
+        // the desk keeps its copy whatever comes down to your chip.
+        const wc = this.scene.getWinCondition?.();
+        if (wc?.type === 'erase' && wc.item.toLowerCase() === item.name.toLowerCase()) {
+            return `Pulling ${item.name} down changes nothing -- the desk keeps its own. ${hint(`"erase ${item.name}" is what makes it go away (Edit File, p.239).`)}`;
+        }
         // THE CONVERSION, identical to take.ts's. Same two fields, because a
         // file that came down by one verb and a file that came down by the
         // other must be the same object afterwards -- a chip you can `give`.

package/bundle/typescript/src/commands/game/sideQuest/commands/edit-file.js

@@ -0,0 +1,132 @@
+import { Command } from './command.js';
+import { hint } from '../utilities/hints.js';
+import { rollPool, formatRoll } from '../utilities/dice.js';
+import { billAction } from '../utilities/action-cost.js';
+import { hostDefensePool } from '../utilities/matrix-intrusion.js';
+import { hostLabel } from '../utilities/grid-names.js';
+import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+/**
+ * EDIT FILE (SR5 p.239, RAG-checked 2026-09-14): a Complex Action, Marks
+ * Required 1, Computer + Logic [Data Processing] v. Intuition + Firewall.
+ * "Edit File allows you to create, change, copy, delete, or protect any
+ * kind of file. The defender against this test is either the host
+ * holding the file or the owner of the file." It is a DATA PROCESSING
+ * action -- not Attack, not Sleaze -- so it is legal and GOD does not
+ * count it (p.231, and the worked example at p.231-232: "since that's a
+ * Data Processing action, he doesn't need to worry about his OS going up
+ * again"). A failed edit is not a blown Sleaze either: nothing upstairs
+ * notices a checksum that held.
+ *
+ * WHAT SHIPS (loose ends, 2026-09-14): DELETE. The cleanup's objective
+ * is a file the site keeps -- camera footage with the runner's face --
+ * and copying it (the engine's `take` / `download`, which already
+ * converts a matrix file to a chip) changes nothing about what the desk
+ * still holds. Create, change and protect are named here as not built;
+ * Crack File and the Data Bomb family wait on a per-file protection
+ * rating (models/item.ts) and are their own item.
+ *
+ * TWO ENGINE RULINGS, both labelled. Canon is silent on how a file INSIDE
+ * a host is marked (only archive files carry marks, p.247): here the
+ * persona must be inside the host and hold a mark on it -- the host is
+ * the file's keeper and the door was the mark. And a host has no
+ * Intuition to defend with: Host Rating + Firewall stands in, exactly
+ * the hostDefensePool ruling the intrusion roll already makes.
+ *
+ * FOUND FIRST: the archive is listed for a persona whose Matrix Search
+ * turned it up (Host.searchedBy, commands/search.ts) or once the host is
+ * cracked. You cannot delete what you have not seen.
+ */
+export class EditFileCommand extends Command {
+    static verb = 'edit';
+    static description = 'Edit File (Complex Action, SR5 p.239): "edit delete <file>" -- Computer + Logic [Data Processing] v. the host\'s Rating + Firewall, from inside the host with a mark on it, once a search has turned the file up. A Data Processing action: legal, and GOD does not count it. "erase <file>" is the same delete.';
+    /** The operation this verb form performs; the delete forms fix it. */
+    operation(args) {
+        const first = (args[0] ?? '').toLowerCase();
+        if (/^(delete|erase|wipe|remove)$/.test(first))
+            return { op: 'delete', rest: args.slice(1) };
+        if (/^(create|change|copy|protect)$/.test(first))
+            return { op: 'other', word: first, rest: args.slice(1) };
+        return { op: 'other', rest: args };
+    }
+    async execute(args = []) {
+        const actor = this.actor;
+        const { op, word, rest } = this.operation(args);
+        if (op !== 'delete') {
+            const named = word ? `"${word}"` : 'that';
+            return `Edit File (p.239) can create, change, copy, delete or protect a file -- and this engine builds DELETE: "edit delete <file>" (or "erase <file>"). ${word === 'copy' ? 'Copying is "take" or "download" -- the file comes down to a chip.' : `${named} isn't built yet.`}`;
+        }
+        if (actor.plane !== 'matrix') {
+            return `Files are edited by a persona. ${hint(`"jack in" first.`)}`;
+        }
+        const host = actor.hostInside;
+        if (!host) {
+            return `You edit a host's files from INSIDE it (p.246). ${hint(`"enter" the host that keeps it.`)}`;
+        }
+        const room = host.over;
+        const files = host.files();
+        const query = rest.join(' ').trim();
+        if (!query) {
+            return files.length === 0
+                ? `${hostLabel(room, { capital: true })} keeps nothing here to edit.`
+                : `Edit which file? ${hint(`("edit delete <file>". "search" lists the archive.)`)}`;
+        }
+        const found = host.searchedBy.has(actor.name) || room.hostCracked;
+        if (!found) {
+            return `You haven't found ${hostLabel(room)}'s archive yet -- there is nothing on your display to edit. ${hint(`"search" runs a Matrix Search inside the host (p.241).`)}`;
+        }
+        const picked = fuzzyPickName(query, files.map(f => f.name));
+        const file = picked ? files.find(f => f.name === picked) : undefined;
+        if (!file) {
+            return `No file called "${query}" in ${hostLabel(room)}'s archive.${files.length > 0 ? hint(` (It holds: ${files.map(f => f.name).join(', ')}.)`) : ''}`;
+        }
+        const marks = room.hostMarksBy.get(actor.name) ?? 0;
+        if (marks < 1) {
+            return `Edit File needs a MARK (p.239) -- you hold none on ${hostLabel(room)}. ${hint(`"hack" the host for one.`)}`;
+        }
+        // Binder IC eats Data Processing; a bracket of 0 permits no hits.
+        const burned = actor.burnedAttributeRefusal('dataProcessing');
+        if (burned)
+            return burned;
+        const bill = billAction(this.scene, actor, 'complex', 'Edit File');
+        if (bill)
+            return bill;
+        const computer = actor.skillRating('computer');
+        // Inside a host no grid penalty applies (p.246); silence still taxes
+        // every Matrix action (p.235-236, Player.matrixActionPenalty).
+        const pool = Math.max(1, actor.logic + (computer > 0 ? computer : -1)
+            + actor.matrixActionPenalty + actor.woundModifier - actor.sustainingPenalty);
+        const limit = actor.matrixAttribute('dataProcessing');
+        const defence = hostDefensePool(host);
+        const attempt = rollPool(pool, limit, { gremlins: actor.deckGremlins });
+        const resist = rollPool(defence.pool);
+        if (this.scene.isHumanControlled(actor)) {
+            this.logger.meta(`Edit File (delete) -- Computer + Logic [Data Processing]: ${formatRoll(attempt)}`);
+            this.logger.meta(`  v. ${hostLabel(room)} (${defence.label}, rating standing in for Intuition): ${formatRoll(resist)}`);
+        }
+        actor.performAction('edits a file', `${file.name} in ${hostLabel(room)}`, { quiet: this.scene.isHumanControlled(actor) });
+        if (attempt.hits <= resist.hits) {
+            this.logger.write(`${actor.name} failed to delete "${file.name}" in ${room.name}: ${attempt.hits} v ${resist.hits}.`);
+            return `The file's checksum holds -- your edit rolls off it and the archive keeps ${file.name}. Nothing upstairs noticed: a failed edit is not a failed sleaze.${hint(` (Try again; each attempt is a Complex Action.)`)}`;
+        }
+        room.inventory.removeItem(file.name);
+        room.plainSightItems.delete(file.name.toLowerCase());
+        this.logger.write(`${actor.name} deleted "${file.name}" from ${room.name}'s host: ${attempt.hits} v ${resist.hits}.`);
+        this.scene.addWorldEvent(`${file.name} was erased from ${host.name}'s archive.`);
+        const banner = this.scene.checkErased?.(file.name, actor.name);
+        this.scene.updateStatus();
+        return [
+            `{lightblue-fg}${file.name} comes apart under your hand -- sectors zeroed, index entry gone, the host's own checksum rewritten to agree. ${hostLabel(room, { capital: true })} no longer has it.{/lightblue-fg}`,
+            ...(banner ? [banner] : []),
+        ].join('\n');
+    }
+}
+/** "erase <file>" / "wipe <file>": the delete form under its own name. */
+export class EraseCommand extends EditFileCommand {
+    static verb = 'erase';
+    static description = 'Erase a file inside a host -- Edit File\'s delete (SR5 p.239): Computer + Logic [Data Processing] v. the host\'s Rating + Firewall, with a mark on the host, once "search" has turned the file up. Legal: GOD does not count it.';
+    operation(args) {
+        const first = (args[0] ?? '').toLowerCase();
+        return { op: 'delete', rest: /^(delete|erase|wipe|remove)$/.test(first) ? args.slice(1) : args };
+    }
+}
+//# sourceMappingURL=edit-file.js.map

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

@@ -26,34 +26,52 @@ export class HopCommand extends Command {
         if (actor.hostInside) {
             return `You're inside ${actor.hostInside.name}'s host -- there is no grid under you to hop from. ${hint(`"exit" first.`)}`;
         }
-        const district = this.scene.localGrid;
         const game = this.game ?? undefined;
+        // A LOOSE-END CLEANUP HAS ONE DOOR (Game.enterCleanup, 2026-09-14):
+        // the persona hopped onto the site's grid and the only way off it is
+        // "jack out" -- hopping elsewhere would leave a scene with nobody in
+        // it and a body with no way back.
+        if (game?.inCleanup) {
+            return `Not from here -- this is the site's grid, and the only way off it is "jack out".`;
+        }
+        const district = this.scene.localGrid;
         const tier = game?.lifestyleTier ?? 'Street';
         const provider = game?.gridProvider ?? DEFAULT_GRID_PROVIDER;
         const query = args.join(' ').trim();
         const reachable = gridsWithAccess(tier, district, provider);
+        // LOOSE ENDS (Game.looseEndGrids): a site that kept your face runs a
+        // grid of its own, listed while the footage is still up there. No
+        // subscription buys it, so it is always the Hack on the Fly hop.
+        // Optional call: test stubs stand in for Game here (hop.test.ts).
+        const looseEnds = game?.looseEndGrids?.() ?? [];
+        const extras = looseEnds.map(e => e.grid);
         if (!query) {
             const here = actor.currentGrid?.name ?? 'an unnamed grid';
             return [
                 `You're on ${here}.`,
                 `  Grids you can hop to freely: ${reachable.map(g => g.name).join(', ')}.`,
-                hint(`  ("hop <grid>" -- public, local, or a Big Ten name. Anywhere else takes Hack on the Fly.)`),
+                ...(extras.length > 0 ? [`  {yellow-fg}Loose ends: ${looseEnds.map(e => `${e.grid.name} (your face from "${e.looseEnd.jobName}")`).join(', ')}{/yellow-fg} -- no subscription: Hack on the Fly v. 4 dice (p.240).`] : []),
+                hint(`  ("hop <grid>" -- public, local, or a Big Ten name${extras.length > 0 ? ', or a site with a loose end' : ''}. Anywhere else takes Hack on the Fly.)`),
             ].join('\n');
         }
-        const target = resolveGridName(query, district);
+        const target = resolveGridName(query, district, extras);
         if (!target) {
             return `No grid answers to "${query}". ${hint(`Try "hop public", "hop local", or a Big Ten name -- Ares, Aztechnology, Evo, Horizon, Mitsuhama, NeoNET, Renraku, Saeder-Krupp, Shiawase, Wuxing.`)}`;
         }
         if (actor.currentGrid && actor.currentGrid.key === target.key) {
             return `You're already on ${target.name}.`;
         }
+        const isLooseEnd = extras.some(g => g.key === target.key);
+        // THE DROP (Game.enterCleanup): after the hop lands on a site grid,
+        // the site's host is what hangs overhead now.
+        const land = async () => isLooseEnd && game ? (await game.enterCleanup(target)).join('\n') : '';
         if (hasAccess(tier, district, target, provider)) {
             actor.matrixPosition = { kind: 'grid', grid: target };
             movePersonaWith(game, actor);
             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 `{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.`)}` : ''}`;
+            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.`)}` : ''}${await land()}`;
         }
         // ILLEGAL HOP (p.240): Hack on the Fly against the grid itself.
         const burned = actor.burnedAttributeRefusal('sleaze');
@@ -89,6 +107,7 @@ export class HopCommand extends Command {
         return [
             `{lightblue-fg}You slip through a seam nobody sold you and come up on ${target.name}.{/lightblue-fg}`,
             ...bill.lines,
+            ...(isLooseEnd ? [await land()] : []),
         ].join('\n');
     }
 }

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

@@ -65,6 +65,15 @@ export class JobsCommand extends Command {
                 entries.push({ tag: 'LOCAL', kind: 'active', name: pending.name, detail: `this machine only${tail}` });
             }
         }
+        // LOOSE ENDS (2026-09-14): not jobs -- nobody is paying -- but they
+        // are the other thing on the runner's plate, and the board is where a
+        // player looks. Read-only here: the way in is the Matrix (journal.ts).
+        for (const le of game.looseEnds ?? []) {
+            entries.push({
+                tag: 'LOOSE END', kind: 'loose-end', name: `Footage at ${le.site}`,
+                detail: `${le.site}'s cameras kept your face from "${le.jobName}" -- "jack in", then "hop ${le.site}"${le.homecomingsLeft <= 1 ? '; the desk reviews the feeds after your next job' : ''}`,
+            });
+        }
         // Standing drafts: ONLY the ones whose quoted crew is seated right
         // now (the ruling), and never the one already on the table.
         if (game.hasHub && !this.gameAnonymous()) {
@@ -92,6 +101,9 @@ export class JobsCommand extends Command {
     }
     async take(entry) {
         const game = this.game;
+        if (entry.kind === 'loose-end') {
+            return `A loose end isn't taken, it's tied off -- from the Matrix. "jack in", then "hop" onto the site's grid and erase what they kept.`;
+        }
         if (entry.kind === 'active') {
             // Same phantom verb as buildBoard's, same fix: the ride is "call
             // taxi" whether the seat is yours alone or the table's, so there
@@ -117,6 +129,9 @@ export class JobsCommand extends Command {
     }
     async dismiss(entry) {
         const game = this.game;
+        if (entry.kind === 'loose-end') {
+            return `You can't wave off what a camera already has. Erase it, or let the desk find it.`;
+        }
         if (entry.kind === 'active') {
             const wasCrew = entry.tag === 'CREW';
             // Explicit dismissal kills the server draft too -- that's the

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

@@ -92,10 +92,19 @@ export class JournalCommand extends Command {
         if (wc.payout !== undefined && wc.payout > 0) {
             rows.push(`${BULLET}{bold}Pay:{/bold} ${wc.payout.toLocaleString()}¥ ${isDelivery ? 'on delivery' : 'on the wrap'}`);
         }
-        const objective = isDelivery
-            ? `deliver ${wc.item} to ${wc.toNpc}`
-            : `come away with ${wc.item}`;
+        // A loose end is ERASED, not carried (win-condition-seed.ts 'erase').
+        const isErase = wc.type === 'erase';
+        const objective = isErase
+            ? `erase ${wc.item}`
+            : isDelivery
+                ? `deliver ${wc.item} to ${wc.toNpc}`
+                : `come away with ${wc.item}`;
         rows.push(`${BULLET}{bold}Objective:{/bold} ${objective}`);
+        if (isErase) {
+            if (this.scene?.isCompleted?.())
+                rows.push(`${BULLET}{bold}Status:{/bold} erased -- "jack out" closes the grid`);
+            return rows;
+        }
         // Held or not is a live read of the player's own pack.
         const holding = this.actor.inventory?.hasItem?.(wc.item);
         if (holding)
@@ -130,6 +139,11 @@ export class JournalCommand extends Command {
         if (game.rentDebt > 0) {
             lines.push(`${BULLET}{bold}Owed:{/bold} ${game.rentDebt.toLocaleString()}¥ on the tab`);
         }
+        // LOOSE ENDS (2026-09-14): what a run left behind that can still be
+        // fixed -- from the Matrix, not the curb.
+        for (const le of game.looseEnds ?? []) { // stubs stand in for Game in journal.test.ts
+            lines.push(`${BULLET}{bold}Loose end:{/bold} ${le.site}'s cameras kept your face from "${le.jobName}"${le.homecomingsLeft <= 1 ? ' -- the desk reviews the feeds after your next job' : ''}${hint(` ("jack in", then "hop ${le.site}" -- erase it before the desk finds it.)`)}`);
+        }
         return lines.join('\n') + hint(`\n("jobs" shows the board.)`);
     }
 }

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

@@ -170,6 +170,9 @@ export class SheetCommand extends Command {
             row('Needs', `${a.ateThisCycle ? 'fed' : 'HUNGRY'}, ${a.sleptThisCycle ? 'slept' : 'SHORT ON SLEEP'}${a.ateThisCycle && a.sleptThisCycle ? '' : ' -- edge will NOT refill'}`),
             row('Rep', `Cred ${a.streetCred} / Notoriety ${a.notoriety} / Awareness ${a.publicAwareness}${hint(`${a.socialRep > 0 ? ` -- +${a.socialRep} dice haggle/persuade` : ''}${a.notoriety > 0 ? `; threats +${Math.min(3, a.notoriety)}` : ''}${a.publicAwareness > 0 ? `; cons -${Math.min(2, a.publicAwareness)}` : ''}`)}`),
             ...(a.notorietyReasons.length > 0 ? [row('Stains', a.notorietyReasons.join('; '))] : []),
+            // LOOSE ENDS (2026-09-14): footage a site still holds -- erasable
+            // from the Matrix until the desk reviews it (ILooseEnd).
+            ...((this.game?.looseEnds.length ?? 0) > 0 ? [row('Loose ends', this.game.looseEnds.map(le => `${le.site} has your face from "${le.jobName}"`).join('; ') + hint(' ("journal" for how to fix it)'))] : []),
             ...(a.initiationGrade > 0 ? [row(a.isTechnomancer() ? 'Submersion' : 'Initiation', `grade ${a.initiationGrade} -- ${catalogMetamagics().filter(m => a.hasMetamagic(m.key)).map(m => m.name).join(', ')}`)] : []),
             ...(a.lockedFatigue > 0 ? [row('Fatigue', `${a.lockedFatigue} stun LOCKED until the need is met`)] : []),
             ...(a.woundModifier < 0 ? [row('Wounds', `${a.woundModifier} dice on everything`)] : []),

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

@@ -185,6 +185,13 @@ export class TakeCommand extends Command {
         let tookAnything = false;
         const taken = [];
         for (const item of items) {
+            // The sweep skips a file the objective says to ERASE -- see the
+            // single-take refusal below for why a copy is not a fix.
+            const wcAll = this.scene.getWinCondition?.();
+            if (item.plane === 'matrix' && wcAll?.type === 'erase' && wcAll.item.toLowerCase() === item.name.toLowerCase()) {
+                lines.push(`  • left the {bold}{underline}${item.name}{/underline}{/bold} -- copying it changes nothing; "erase" it`);
+                continue;
+            }
             try {
                 this.actor.addInventory(item);
                 // THE SWEEP DOWNLOADS TOO. Same rule as the single take below,
@@ -316,6 +323,15 @@ export class TakeCommand extends Command {
             if (reach === 'enter') {
                 return `The ${item.name} is INSIDE the host -- you're on the outside grid, reading its shell (p.246). ${(room.hostMarksBy.get(this.actor.name) ?? 0) > 0 || room.hostCracked ? `"enter" first.` : `Get a mark on it and "enter" -- or "hack" your way in.`}`;
             }
+            // A LOOSE END IS ERASED, NOT CARRIED (win-condition-seed.ts 'erase',
+            // 2026-09-14): pulling the footage down to a chip leaves the desk's
+            // copy exactly where it was, and would let a runner believe the
+            // night was dealt with. The objective's own verb is "erase" --
+            // said before the seal, because it is the refusal that teaches.
+            const wc = this.scene.getWinCondition?.();
+            if (wc?.type === 'erase' && wc.item.toLowerCase() === item.name.toLowerCase()) {
+                return `Copying ${item.name} changes nothing -- the desk keeps its own. ${hint(`"erase ${item.name}" is what makes it go away (Edit File, p.239).`)}`;
+            }
             // Same split as look.ts: the host's seal does not reach a box that
             // is not on the network. The air gap IS the server's security.
             if (room.hasNode && !room.offlineServer && !room.hostCracked) {

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,27 @@
 //   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.
+// 1.55.0 (2026-09-14): LOOSE ENDS. A run that ends with a camera's footage
+//   still live on an uncracked host leaves an ILooseEnd on the save
+//   (save.game.looseEnds, additive; a hosted run carries it on
+//   pendingHomecoming.footage). From the hub a Matrix-capable runner
+//   jacks in, "hop"s onto the site's grid (Hack on the Fly v. 4 dice,
+//   p.240), is dropped into a one-host cleanup scene, cracks and
+//   searches the host and ERASES the file with the new Edit File verb
+//   ("edit delete" / "erase", p.239, a Data Processing action GOD does
+//   not count); jacking out -- by any door -- hands the hub back. No
+//   taxi, no pay. Left one full homecoming, the desk reviews the feeds:
+//   +1 Public Awareness. New SaveReason 'cleanup'; new win condition
+//   type 'erase'. The site reads Game.footageLeft() off the live handle.
+export const ENGINE_VERSION = '1.55.0';
 //# sourceMappingURL=engine-version.js.map

package/bundle/typescript/src/commands/game/sideQuest/factories/cleanup-seed.js

@@ -0,0 +1,89 @@
+/**
+ * THE LOOSE-END CLEANUP SEED (2026-09-14). Deterministic and hand-built
+ * -- no LLM, no AI key, instant -- rebuilt from the record every time
+ * the runner hops onto the site's grid (utilities/grids.ts
+ * looseEndGrid, Game.enterCleanup), and thrown away when they jack out.
+ *
+ * ONE ROOM: the site's host, standing over the room the cameras are
+ * slaved to. It is never reachable in the meat (`reachable: false`, the
+ * fixer's-hideout convention) because nobody is going there -- the
+ * persona is dropped onto the site's grid and the host hangs overhead,
+ * reachable by name from anywhere on it (utilities/grid-reach.ts). The
+ * body's own room is added by the caller, so the body has somewhere to
+ * be; it is not part of this seed.
+ *
+ * ONE FILE: the footage, a matrix-plane Document in the host's room --
+ * the shape Host.files() reads (models/host.ts) and the data run's
+ * paydata already takes (factories/repro-scene.ts). The objective is to
+ * ERASE it (Edit File, p.239; win-condition-seed.ts 'erase'), not to
+ * take it: copying it changes nothing about what the desk keeps.
+ *
+ * NO CLIENT, NO PAYOUT, NO NPCS: nobody hired the runner for this. Ice
+ * is the host's to launch at runtime (utilities/host-combat.ts); the
+ * generator's rule that no seed writes matrix-plane NPCs holds here too.
+ */
+export const FOOTAGE_FILE_PREFIX = 'Security Footage';
+export function footageFileName(le) {
+    return `${FOOTAGE_FILE_PREFIX} -- ${le.site}`;
+}
+export function cleanupSceneName(le) {
+    return `Loose end: ${le.site}`;
+}
+export function buildCleanupSeed(le, playerName) {
+    const file = footageFileName(le);
+    const when = le.capturedAt.slice(0, 10);
+    const rooms = le.rooms.length > 0 ? le.rooms.join(', ') : le.site;
+    return {
+        name: cleanupSceneName(le),
+        story: `${le.site}'s cameras kept your face from "${le.jobName}" -- and the footage is sitting on the site's own host, waiting for a security desk that has not got round to it yet. You are on ${le.site}'s grid. The host hangs overhead. Nobody is paying for this one; nobody else is coming to fix it.`,
+        currency: { type: 'nuyen', authorityRoomTags: [] },
+        residenceTiers: [],
+        rooms: [
+            {
+                name: le.host.room,
+                description: `The room ${le.site}'s cameras report to. You will never stand in it -- its host is what you are here for.`,
+                roomType: 'Office',
+                isStartRoom: true,
+                reachable: false,
+                hasNode: true,
+                hostRating: le.host.rating,
+                hostGrid: 'local',
+                hostPurpose: le.host.purpose ?? `${le.site}'s security feeds and door logs`,
+                hostSculpt: le.host.sculpt,
+                watched: true,
+                exits: [],
+            },
+        ],
+        npcs: [],
+        items: [
+            {
+                name: file,
+                description: `Camera footage from ${rooms}, ${when}: a runner's face, in full, from the night of "${le.jobName}". Yours.`,
+                details: `Feeds from ${rooms}. Not yet reviewed by the desk.`,
+                size: 'Tiny',
+                category: 'Document',
+                shape: 'Rectangle',
+                color: 'Gray',
+                texture: 'Plain',
+                rating: 'Common',
+                weight: 0.1,
+                plane: 'matrix',
+                room: le.host.room,
+            },
+        ],
+        puzzles: [],
+        winCondition: {
+            type: 'erase',
+            item: file,
+            completionMessage: `The file shreds under your hand and the feeds loop on an empty hallway. ${le.site} never kept your face.`,
+        },
+        cleanup: { looseEndId: le.id },
+        player: {
+            name: playerName,
+            startLocation: le.host.room,
+            lifestyleChoices: [],
+            startingItems: [],
+        },
+    };
+}
+//# sourceMappingURL=cleanup-seed.js.map