@maka/maka-cli 5.185.0 → 5.187.0

package/bundle/typescript/package.json

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

@@ -556,6 +556,31 @@ export class HackCommand extends BypassCommand {
             this.logger.meta(`${defense.label} (DR ${device.rating}): ${formatRoll(defenseRoll)} -- net ${netHits >= 0 ? '+' : ''}${netHits}`);
         }
         const godLines = this.godBill(overwatchFromDefense(defenseRoll.hits), `device intrusion (${mode})`);
+        // WHY THE KEYS YOU ALREADY HOLD DID NOT OPEN THIS (u8u2koi3THQM9dzSz:
+        // "I _OWN_ the host with 3 marks, I should be able to hack the
+        // maglock, or simply disable it").
+        //
+        // Checked against the books rather than the report's own reading:
+        // marks share ONE WAY. "If you get a mark on a slave you also get a
+        // mark on the master ... This doesn't work both ways" (p.233). Three
+        // marks on the host are three marks on the HOST; the lock hanging off
+        // it is still its own icon with its own monitor, and Control Device
+        // (p.238) counts marks on the thing being controlled. So the engine
+        // was right to make them roll -- and said nothing at all about why,
+        // which is the part that earned the report. A rule the player cannot
+        // see is indistinguishable from a bug.
+        //
+        // The line also names the move that DOES cash those marks in: inside
+        // the host you are directly connected to everything on its WAN, and
+        // a directly-connected slave "cannot use its master's ratings to
+        // defend itself" (p.233) -- which is exactly the pool that just beat
+        // them. Only said when they actually hold host marks and are still
+        // outside; from in here it would be telling them to walk through the
+        // door they are standing in.
+        const hostMarksHeld = viaWan && host ? host.hostMarksBy.get(actor.name) ?? 0 : 0;
+        const wanNote = hostMarksHeld > 0
+            ? hint(` (Your ${hostMarksHeld} mark${hostMarksHeld === 1 ? '' : 's'} on ${hostLabel(host)} buy nothing against the lock itself -- marks run slave-to-master, never master-to-slave (p.233). "enter ${hostLabel(host)}": from inside its WAN you are directly connected, and ${device.name} has to defend on DR ${device.rating} alone.)`)
+            : '';
         if (netHits <= 0) {
             if (mode === 'sleaze') {
                 // A blown Sleaze is NOTICED (p.236) -- and a slaved device that
@@ -565,14 +590,14 @@ export class HackCommand extends BypassCommand {
                     host.hostAlert = true;
                     this.scene.addWorldEvent(`${device.name} flags a bad handshake -- ${hostLabel(host, { capital: true })} is awake.`);
                     this.scene.updateStatus();
-                    return [`${device.name} refuses the key and SAYS SO -- the node it answers to knows something is in here.`, ...godLines].join('\n');
+                    return [`${device.name} refuses the key and SAYS SO -- the node it answers to knows something is in here.${wanNote}`, ...godLines].join('\n');
                 }
                 // A loose device has no host to wake; its owner still gets the
                 // mark on you a blown Sleaze hands over (p.240).
                 this.scene.updateStatus();
                 return [`${device.name} refuses the key and SAYS SO -- whoever owns it has your icon on file now.`, ...godLines].join('\n');
             }
-            return [`${device.name} holds against the smash -- its firewall never even flexes. Nobody upstairs noticed.`, ...godLines].join('\n');
+            return [`${device.name} holds against the smash -- its firewall never even flexes. Nobody upstairs noticed.${wanNote}`, ...godLines].join('\n');
         }
         const now = Math.min(MAX_MARKS, held + declared);
         device.marksBy.set(actor.name, now);

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/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/engine-version.js

@@ -459,5 +459,17 @@
 //   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';
+// 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

package/bundle/typescript/src/commands/game/sideQuest/factories/scene-chunks.js

@@ -733,6 +733,15 @@ For EVERY item in the skeleton, expand it into a full item ("name" and "category
 Clue requirements (mechanically validated -- the exact phrase must appear in "details"):
 ${clueSpecs || '- (no clue items in this scene)'}
 
+THE ONLY PRIZE IN THIS WORLD is "${skeleton.winCondition?.item ?? ''}" -- the item
+"winCondition" is for. No other item may present itself as the thing the client wants: not
+"it's what ${skeleton.winCondition?.toNpc || skeleton.client || 'the Johnson'} is looking
+for", not "this is what the job is about", not a second set of goods that reads like the
+objective wearing a different name. The engine stars exactly one item and pays out on
+exactly one; a second item that CLAIMS the role sends the runner home with the wrong thing
+in their pack, believing they blew the job they just finished. Loot is loot -- say what it
+IS, never what it is worth to the client.
+
 THE ONLY CODES IN THIS WORLD are the clue phrases listed just above. No other item may
 carry a code-shaped string -- no serial numbers, no model numbers, no unit or locker or
 apartment numbers, no "access code" on a scrap of paper that isn't a listed clue. A player
@@ -2046,6 +2055,112 @@ export function ensureCredentialKindAgrees(details) {
     }
     return notes;
 }
+/**
+ * ONE PRIZE, AND THE PROSE HAS TO AGREE (aSpARWJXXieMAL4eM, 2026-09-14:
+ * "the item marked with the star as the mission objective was 'The
+ * Scout's Contact Sheet'. But the mission was clearly about camera
+ * data ... When I returned to the Hub, I had 'Developed Negatives',
+ * which state it's what Mr. Leger is looking for. It's like the two
+ * items got mis labeld as to what was important.").
+ *
+ * Nothing was mislabelled in the STATE. winCondition.item was the
+ * contact sheet, the star followed it (planes.ts objectiveMark), the
+ * completion check accepted it, and the payout landed. What went wrong
+ * is that the items pass wrote a SECOND item's flavour as though that
+ * one were the job -- so the run had one prize by the engine's reckoning
+ * and a different one by its own prose, and the player believed the
+ * prose. That is worse than a wrong star: they finished the job
+ * convinced they had failed it.
+ *
+ * Same family as payoutSummary and heatSummary in npc.ts -- the model
+ * inventing a fact the engine already owns -- and the same answer:
+ * state the fact in the prompt (buildItemsPrompt, "THE ONLY PRIZE IN
+ * THIS WORLD"), and enforce it here so a draft that ignores the rule
+ * costs nothing.
+ *
+ * SURGERY, narrowly, and this file's own preference is against it:
+ * ensureCredentialKindAgrees corrects "by ADDING a plain sentence rather
+ * than rewriting generated prose". That works when the generated line is
+ * merely incomplete. It cannot work here, because the line is FALSE --
+ * appending "but the client doesn't want this" under "this is what the
+ * client wants" leaves prose that argues with itself, which is exactly
+ * the confusion the report describes. So the false sentence comes out,
+ * whole, and everything around it is left byte-identical.
+ *
+ * THE BAR IS THREE THINGS IN ONE SENTENCE, because two is not enough to
+ * tell a claim from colour: someone the job is ABOUT (the client by
+ * name, or a generic for them), a verb of WANTING, and a reference back
+ * to THIS item. "Ledger drinks alone and wants nothing from anybody"
+ * keeps all three words apart and survives; "it's what Mr. Ledger is
+ * looking for" does not.
+ */
+const PRIZE_WANTING = /\b(look(?:s|ing|ed)?\s+for|after\s+(?:this|it|these|them)|want(?:s|ed|ing)?|need(?:s|ed|ing)?|ask(?:s|ed|ing)?\s+for|pay(?:s|ing)?\s+for|hir(?:ed|ing)\s+\w+\s+for|sent\s+\w+\s+for|came\s+for|is\s+the\s+(?:job|prize|objective|target))\b/i;
+const PRIZE_SELF = /\b(this|these|those|it|its|it's|the\s+one)\b/i;
+const PRIZE_GENERIC_CLIENT = /\b(the\s+client|the\s+johnson|mr\.?\s+johnson|your\s+employer|the\s+employer|the\s+buyer|the\s+job|the\s+run|the\s+contract)\b/i;
+/**
+ * Sentence-ish split that keeps the terminator with its sentence.
+ *
+ * IT DOES HAVE TO HANDLE "Mr." -- this comment first said it didn't,
+ * and the first test written against it failed. Every client in this
+ * game is "a Mr. Johnson" (canon p.27-28), so the one sentence this
+ * function exists to read -- "It's what Mr. Ledger is looking for." --
+ * is precisely the one a naive split cuts in half, into two fragments
+ * neither of which claims anything. The titles below are the ones a
+ * Shadowrun scene actually writes; a single capital initial ("J.
+ * Ledger") goes with them.
+ */
+const SENTENCE_BREAK = /(?<!\b(?:Mr|Mrs|Ms|Dr|Sr|Jr|St|Prof|Rev|Inc|Ltd|Co|vs|No|[A-Z])\.)(?<=[.!?])\s+/;
+function prizeSentences(text) {
+    return text.split(SENTENCE_BREAK).filter(s => s.length > 0);
+}
+function claimsThePrize(sentence, clientNames) {
+    if (!PRIZE_WANTING.test(sentence) || !PRIZE_SELF.test(sentence))
+        return false;
+    const named = clientNames.some(n => n.length > 0 && sentence.toLowerCase().includes(n.toLowerCase()));
+    return named || PRIZE_GENERIC_CLIENT.test(sentence);
+}
+export function ensureOnePrize(skeleton, details) {
+    const notes = [];
+    const prize = (skeleton.winCondition?.item ?? '').trim().toLowerCase();
+    if (prize.length === 0)
+        return notes;
+    // The people a claim can be made on behalf of: the client who holds
+    // the meet, and whoever the goods are owed to (usually the same
+    // person, sometimes not -- a courier job delivers to a third party).
+    // Last names alone are how these lines actually read ("Ledger takes
+    // the sleeve"), so each name contributes its words too.
+    const clientNames = [skeleton.client ?? '', skeleton.winCondition?.toNpc ?? '']
+        .flatMap(n => [n, ...n.split(/\s+/)])
+        .map(n => n.replace(/[^\w\s'-]/g, '').trim())
+        .filter(n => n.length >= 4);
+    for (const item of details.items ?? []) {
+        if ((item.name ?? '').trim().toLowerCase() === prize)
+            continue;
+        for (const field of ['description', 'details']) {
+            const text = (item[field] ?? '').trim();
+            if (text.length === 0)
+                continue;
+            const kept = prizeSentences(text).filter(s => !claimsThePrize(s, clientNames));
+            if (kept.length === prizeSentences(text).length)
+                continue;
+            const rebuilt = kept.join(' ').trim();
+            // A description is always-visible flavour and cannot be blank --
+            // an item with no line at all reads as a generator failure. A
+            // "details" that empties out simply goes away, which is what an
+            // item with nothing more to say should do.
+            if (field === 'description') {
+                item.description = rebuilt.length > 0
+                    ? rebuilt
+                    : `Someone's property once, and worth carrying if nobody's looking.`;
+            }
+            else {
+                item.details = rebuilt.length > 0 ? rebuilt : undefined;
+            }
+            notes.push(`normalized: item "${item.name}" claimed in its ${field} to be what the job is for; "${skeleton.winCondition.item}" is, so the claim was cut.`);
+        }
+    }
+    return notes;
+}
 /**
  * RESOLVE A NAME ONE LIST WROTE AGAINST THE LIST THAT OWNS IT.
  *
@@ -2110,6 +2225,7 @@ export function assembleScene(skeleton, details, playerName) {
     // The answer has to be legible before anything is assembled from it.
     ensureClueDetails(skeleton, details);
     ensureCredentialKindAgrees(details);
+    ensureOnePrize(skeleton, details);
     const roomDetail = new Map(details.rooms.map(r => [r.name, r]));
     const npcDetail = new Map(details.npcs.map(n => [n.name, n]));
     const deviceDetail = new Map(details.devices.map(d => [d.name, d]));

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';
@@ -523,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)
@@ -2749,6 +2937,11 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         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).
@@ -3134,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
@@ -3258,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
@@ -3575,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,
@@ -3670,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();
         }
@@ -3880,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})`
             : '';
@@ -3975,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
@@ -3987,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
@@ -4121,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'
@@ -4128,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;
@@ -6281,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'], ['hide'], ['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.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/npc.js

@@ -458,6 +458,28 @@ export function splitSpokenLines(lines) {
             rebuilt.push(`[COMMAND] say ${bracketed[1]}`);
             continue;
         }
+        // ...AND SO IS ONE FILED UNDER A TAG THE MODEL INVENTED
+        // (zQTWGJFWDXoLtiJX6, 2026-09-13: Whisper's whole sales line
+        // arrived as `[TALK] say Depends what you're buying or
+        // confessing. The credstick's hot and priced like it...` and
+        // printed into the world log verbatim, marker and all -- the
+        // reporter first read it as his OWN typing echoed back).
+        //
+        // Third sighting of one root: the model reaches for the bracket
+        // convention and gets the WORD inside it wrong. [say] was the
+        // second; this is the general case, and generalising beats
+        // adding [TALK] to a list that would need [DIALOGUE], [ACTION]
+        // and whatever the next model invents.
+        //
+        // The bound that holds every repair in this function holds here
+        // too: the VERB after the bracket must be `say`. `[go] north`
+        // stays exactly what it was -- only `say` carries free prose, so
+        // only `say` can be promoted without risking a silent act.
+        const tagged = t.match(/^\[\s*[A-Za-z][A-Za-z ._-]*\s*\]\s*say\s+(\S.*)$/i);
+        if (tagged) {
+            rebuilt.push(`[COMMAND] say ${tagged[1]}`);
+            continue;
+        }
         // ...AND A LINE THAT IS NOTHING BUT SPEECH MARKS IS SPEECH
         // (playtest 2026-08-27, reported twice in one session: 'the
         // "Take a seat..." comment isn't showing as he said it. It's in

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/grid-reach.js

@@ -1,5 +1,6 @@
 import { hostConcealedFrom } from './jackpoint.js';
 import { matchesHostName, hostLabel } from './grid-names.js';
+import { fuzzyPickName } from './fuzzy-match.js';
 /**
  * THE GRID HAS NO STREETS (user canon check 2026-09-02; SR5 pp.217-218,
  * p.246). Jacked in and outside a host, a persona is on its grid: "a
@@ -44,6 +45,28 @@ export function hostOver(room) {
  * anywhere on the grid. Bare "host" (or nothing) means the one over the
  * persona's vicinity, else nothing -- with several overhead, a bare word
  * cannot pick.
+ *
+ * THE ALIAS LIST IS EXACT, AND EXACT IS NOT ENOUGH (qHwKnqEGrJFn3tmF7).
+ * grid-names.ts made the printer and the resolver agree, which fixed
+ * the lie -- but it left the player typing the label back BYTE FOR
+ * BYTE. A run whose room was called "The Grinning Idol -- Back Room"
+ * refused `mark Back Room host` and accepted only
+ * `mark The Grinning Idol -- Back Room host`; the reporter's word for
+ * it was "ridiculous", and they are right. A name you can read off the
+ * screen but not shorten is a name you have to transcribe.
+ *
+ * So: aliases first, unchanged -- an exact hit still resolves exactly,
+ * and the vicinity still wins ties. Only when nothing answers does the
+ * shared fuzzy matcher get a turn, over the names the map actually
+ * printed. It is the same resolver items and NPCs go through, with the
+ * same discipline: an AMBIGUOUS guess misses rather than picking a host
+ * at random, which matters more here than anywhere -- cracking the
+ * wrong node spends the action, wakes the wrong ice and cannot be
+ * taken back.
+ *
+ * The trailing "host"/"node" comes off first: it is part of the LABEL
+ * ("the Back Room host"), never part of the room's name, and leaving it
+ * on drags every score down by a word.
  */
 export function resolveHostInReach(rooms, actor, query) {
     const q = query.trim().toLowerCase();
@@ -56,7 +79,14 @@ export function resolveHostInReach(rooms, actor, query) {
     const near = hostOver(gridVicinity(actor));
     if (near && matchesHostName(q, near))
         return near;
-    return hosts.find(r => matchesHostName(q, r));
+    const exact = hosts.find(r => matchesHostName(q, r));
+    if (exact)
+        return exact;
+    const bare = q.replace(/\s*\b(hosts?|nodes?)\s*$/, '').trim();
+    if (bare.length === 0)
+        return undefined;
+    const picked = fuzzyPickName(bare, hosts.map(r => r.name));
+    return picked ? hosts.find(r => r.name === picked) : undefined;
 }
 /** Noise between the persona and a room's icons: 0 for the vicinity (and inside a host), -DISTRICT_NOISE dice elsewhere. */
 export function noiseFor(actor, room) {

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/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.185.0",
+  "version": "5.187.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.",