@maka/maka-cli 5.200.0 → 5.202.0

package/bundle/typescript/src/commands/game/sideQuest/npc-kits.js

@@ -0,0 +1,295 @@
+import { augFor, itemFromCatalog, npcKitFor } from './utilities/catalog.js';
+import { Category } from './types/shared/item-enum.js';
+import { Logger } from './utilities/logger.js';
+// ============================================================================
+// Tiers
+// ============================================================================
+/**
+ * WHICH KIT A SITE'S SECURITY TIER FIELDS. The slugs match the shipped
+ * rows (maka-cli.com full-catalog.json v21); a row that is missing
+ * resolves to no kit, per the file comment.
+ */
+export const KIT_FOR_TIER = {
+    0: 'thugs',
+    1: 'gangers',
+    2: 'corp-security',
+    3: 'police-patrol',
+    4: 'organized-crime',
+    5: 'elite-corp-security',
+    6: 'elite-special-forces',
+};
+export function kitSlugForTier(tier) {
+    return KIT_FOR_TIER[tier];
+}
+/**
+ * THE MOST A JOB OF THIS SIZE PLAUSIBLY FIELDS. `campaignTier` is the
+ * job number (buildSkeletonPrompt's `tier`), NOT the security tier --
+ * the two words collide and this is the one place they meet. Job #1 is
+ * a warehouse, not an arcology: elite corporate security (PR 5) is a
+ * tier-3+ problem, and PR 6 special forces never come from a generated
+ * draft at all -- a hand-authored seed may declare them.
+ */
+export function maxSecurityTierFor(campaignTier) {
+    if (campaignTier <= 1)
+        return 2;
+    if (campaignTier === 2)
+        return 3;
+    return 5;
+}
+/** What a draft that declared nothing gets: a gang block for job #1, a
+ *  corporate office for #2, a patrolled site after that. */
+export function defaultSecurityTierFor(campaignTier) {
+    if (campaignTier <= 1)
+        return 1;
+    if (campaignTier === 2)
+        return 2;
+    return 3;
+}
+/**
+ * CLAMP, NEVER REJECT. A model that wrote "securityTier": 9, or "high",
+ * or nothing, has still written a usable scene; failing the skeleton
+ * over it would spend a real generation retry on a number the engine
+ * can repair in one line. Same policy as the keyed-door and keyItem
+ * repairs in scene-factory.ts.
+ */
+export function clampSecurityTier(raw, campaignTier) {
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    const base = Number.isFinite(n) ? Math.round(n) : defaultSecurityTierFor(campaignTier);
+    return Math.max(0, Math.min(maxSecurityTierFor(campaignTier), base));
+}
+/**
+ * ROUGHLY WHAT A RANK-AND-FILE GRUNT OF THIS TIER ROLLS, attack pool
+ * plus defense pool, read off the p.381-384 statblocks (Agility +
+ * weapon skill + smartlink/toner; Reaction + Intuition/2 + wired
+ * reflexes). The party's own figure (scene-chunks.ts partyStrength) is
+ * on the same scale, and a party that clears this by a margin draws
+ * the tier's lieutenant.
+ */
+export function expectedStrengthFor(securityTier) {
+    const table = { 0: 11, 1: 12, 2: 13, 3: 12, 4: 16, 5: 25, 6: 29 };
+    return table[Math.max(0, Math.min(6, securityTier))] ?? 12;
+}
+/** The margin past expectedStrengthFor at which a site posts its lieutenant. */
+export const LIEUTENANT_MARGIN = 3;
+export function partyDrawsLieutenant(partyStrength, securityTier) {
+    return partyStrength > expectedStrengthFor(securityTier) + LIEUTENANT_MARGIN;
+}
+// ============================================================================
+// Group Edge and morale (p.379-380)
+// ============================================================================
+/** p.380: "a team of grunts has a Group Edge equal to its Professional Rating." */
+export function groupEdgeFor(professionalRating) {
+    return Math.max(0, Math.min(6, Math.round(professionalRating)));
+}
+/**
+ * p.379-380, verbatim in spirit: PR 0 "will flee if somebody in their
+ * group goes down"; PR 1-2 "retreat if more than a quarter of their
+ * team is taken out"; PR 3-4 "withdraw after casualties exceed half";
+ * PR 5-6 "will not break -- they fight to the last man".
+ */
+export function moraleBandFor(professionalRating) {
+    if (professionalRating <= 0)
+        return 'one-drops';
+    if (professionalRating <= 2)
+        return 'quarter';
+    if (professionalRating <= 4)
+        return 'half';
+    return 'never';
+}
+/** Does a team of `total` that has lost `casualties` break at this PR? */
+export function moraleBreaks(professionalRating, casualties, total) {
+    if (total <= 0 || casualties <= 0)
+        return false;
+    switch (moraleBandFor(professionalRating)) {
+        case 'one-drops': return casualties >= 1;
+        case 'quarter': return casualties > total / 4;
+        case 'half': return casualties > total / 2;
+        case 'never': return false;
+    }
+}
+/** The line the room hears when a team breaks, by how trained it was. */
+export function moraleBreakLine(name, band) {
+    switch (band) {
+        case 'one-drops': return `${name} sees the body drop and wants no part of this -- hands up, backing off.`;
+        case 'quarter': return `${name} has seen enough of their own go down -- weapon lowered, backing out of it.`;
+        default: return `${name} calls it: too many down. Weapon down, hands where you can see them.`;
+    }
+}
+// ============================================================================
+// Outfitting
+// ============================================================================
+/**
+ * WHAT AN NPC WEARS OR HOLDS, out of what a kit puts in its pack. The
+ * one list, shared by scene-factory's equip step and the ephemeral
+ * governor, so a guard built by a seed and a ganger spawned on a corner
+ * dress the same way. Weapons and armor only: a commlink stays in the
+ * pocket, and plot items (keys, chips) stay in inventory where "give"
+ * and the loot lane expect them.
+ */
+export const NPC_EQUIP_CATEGORIES = new Set([
+    Category.Weapon, Category.MeleeWeapon, Category.RangedWeapon,
+    Category.Armor, Category.BodyArmor, Category.ArmorClothing, Category.Shield,
+    Category.Helmet, Category.ArmArmor, Category.LegArmor, Category.Boots, Category.Gloves,
+]);
+const WEAPON_CATEGORIES = new Set([
+    Category.Weapon, Category.MeleeWeapon, Category.RangedWeapon,
+]);
+/**
+ * Slots every weapon and armor piece in the pack into the actor's
+ * equipment, FIRST WEAPON WINS. `equip` swaps, so an unguarded loop
+ * over a pack holding a pistol and a knife ends with the knife in hand
+ * and the pistol holstered -- the exact bug archetypes.ts:outfitArchetype
+ * documents for runners, reproduced here for everyone else. Armor
+ * layers (a helmet over a jacket), so only weapons are guarded.
+ */
+export function equipKitIntoHands(actor) {
+    for (const item of [...actor.inventory.getAllItems()]) {
+        if (!NPC_EQUIP_CATEGORIES.has(item.category))
+            continue;
+        if (WEAPON_CATEGORIES.has(item.category) && actor.getCarriedWeapon())
+            continue;
+        try {
+            actor.equip(item);
+        }
+        catch { /* nothing to slot it into -- stays holstered */ }
+    }
+}
+/**
+ * STAMP A KIT ONTO AN NPC. The NPC analogue of archetypes.ts
+ * outfitArchetype, minus the chargen ledger and the credstick.
+ *
+ * INTO THE PACK, NOT INTO THE HANDS. This adds gear to inventory and
+ * stops; equipping is the caller's step (scene-factory's Step 4.05 for
+ * a seeded NPC, equipKitIntoHands for an ephemeral), because the seeded
+ * path has an author to defer to: an item the seed put in this NPC's
+ * hands with `heldBy` is the author speaking, and the kit skips its
+ * own weapon rather than argue -- `respectCarried` below. Armor still
+ * layers.
+ *
+ * Idempotent on augs and qualities (hasAug / the Set), so a kit applied
+ * twice does not double-install wired reflexes.
+ */
+export function outfitNpcKit(npc, kit, opts = {}) {
+    const logger = Logger.getInstance();
+    const lt = opts.lieutenant ? kit.lieutenant : undefined;
+    const attrs = { ...kit.attributes, ...(lt?.attributes ?? {}) };
+    const skills = { ...kit.skills, ...(lt?.skills ?? {}) };
+    const gear = lt?.gear ?? kit.gear;
+    const ammo = lt?.ammo ?? kit.ammo;
+    const augs = [...kit.augs, ...(lt?.augs ?? [])];
+    const qualities = [...kit.qualities, ...(lt?.qualities ?? [])];
+    const spells = [...kit.spells, ...(lt?.spells ?? [])];
+    const adeptPowers = { ...(kit.adeptPowers ?? {}), ...(lt?.adeptPowers ?? {}) };
+    npc.kit = kit.key;
+    npc.professionalRating = kit.professionalRating;
+    if (opts.lieutenant)
+        npc.lieutenant = true;
+    // The faction feature (factions.ts) ships rows and rules and no seed
+    // wiring; a kit row knows who fields it, so the gap closes here. An
+    // author's explicit faction still wins.
+    if (kit.faction && !npc.faction)
+        npc.faction = kit.faction;
+    npc.body = attrs.body;
+    npc.agility = attrs.agility;
+    npc.reaction = attrs.reaction;
+    npc.strength = attrs.strength;
+    npc.willpower = attrs.willpower;
+    npc.logic = attrs.logic;
+    npc.intuition = attrs.intuition;
+    npc.charisma = attrs.charisma;
+    if (attrs.magic !== undefined)
+        npc.magic = attrs.magic;
+    if (attrs.resonance !== undefined)
+        npc.resonance = attrs.resonance;
+    if (attrs.adept !== undefined)
+        npc.adept = attrs.adept;
+    // Grunts have no Edge POOL of their own (p.380): the team shares one
+    // equal to its PR, held on the CombatEncounter. The RATING stays on
+    // the actor because Player.consumeEdgeBoost adds `this.edge` dice
+    // when a boost lands -- p.56's "add Edge to the dice pool" -- and a
+    // grunt's Edge for that purpose is the group's. edgeRemaining is 0
+    // so nothing reads a per-actor pool.
+    npc.edge = groupEdgeFor(kit.professionalRating + (opts.lieutenant ? 1 : 0));
+    npc.edgeRemaining = 0;
+    // THE KIT IS THE STATLINE: replace, never merge. A `combat.skills`
+    // block a model wrote for a guard is superseded by the book's, and a
+    // merge would keep a dead key like `firearms` alive beside the live ones.
+    npc.skills = { ...skills };
+    const top = Object.entries(skills).sort((a, b) => b[1] - a[1])[0];
+    if (top)
+        npc.combatSkill = top[1];
+    for (const key of qualities) {
+        if (!npc.qualities.has(key))
+            npc.addQuality(key);
+    }
+    for (const key of augs) {
+        const aug = augFor(key);
+        if (aug && !npc.hasAug(key))
+            npc.installAug(aug);
+        else if (!aug)
+            logger.write(`npc-kit ${kit.key}: augmentation "${key}" has no row -- skipped.`);
+    }
+    if (spells.length > 0)
+        npc.knownSpells = [...new Set([...(npc.knownSpells ?? []), ...spells])];
+    if (Object.keys(adeptPowers).length > 0) {
+        npc.adept = true;
+        npc.adeptPowers = { ...(npc.adeptPowers ?? {}), ...adeptPowers };
+    }
+    const carriesWeapon = opts.respectCarried
+        && npc.inventory.getAllItems().some(i => WEAPON_CATEGORIES.has(i.category));
+    let firstGun;
+    for (const slug of gear) {
+        let item;
+        try {
+            item = itemFromCatalog(slug);
+        }
+        catch (err) {
+            // A missing gear row is a catalog problem, logged and survived:
+            // the guard is a little lighter, not absent. The kit suite walks
+            // every slug so this never reaches a player from a shipped row.
+            logger.write(`npc-kit ${kit.key}: ${err instanceof Error ? err.message : String(err)} -- skipped.`);
+            continue;
+        }
+        if (carriesWeapon && WEAPON_CATEGORIES.has(item.category))
+            continue;
+        try {
+            npc.addInventory(item);
+        }
+        catch (err) {
+            logger.write(`npc-kit ${kit.key}: could not give ${npc.name} ${item.name} (${err instanceof Error ? err.message : 'carry cap?'}).`);
+            continue;
+        }
+        item.owner = npc.name;
+        if (!firstGun && item.isFirearm())
+            firstGun = item;
+    }
+    // p.433-434: what is loaded shifts the gun's line -- this is how the
+    // PR 6 HK 227 gets its APDS AP -4 without the row lying about the gun.
+    if (ammo && firstGun) {
+        const round = itemFromCatalogQuiet(ammo);
+        if (round)
+            firstGun.loadedAmmo = round.name;
+    }
+    logger.write(`npc-kit: ${npc.name} outfitted as ${kit.key}${opts.lieutenant ? ' (lieutenant)' : ''} -- PR ${kit.professionalRating}, ${gear.length} piece(s).`);
+}
+function itemFromCatalogQuiet(slug) {
+    try {
+        return itemFromCatalog(slug);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Resolve-and-outfit in one call; a slug with no row is a no-op. Returns whether a kit landed. */
+export function outfitNpcBySlug(npc, slug, opts = {}) {
+    if (!slug)
+        return false;
+    const kit = npcKitFor(slug);
+    if (!kit) {
+        Logger.getInstance().write(`npc-kit: no row for "${slug}" -- ${npc.name} keeps their attribute block.`);
+        return false;
+    }
+    outfitNpcKit(npc, kit, opts);
+    return true;
+}
+//# sourceMappingURL=npc-kits.js.map

package/bundle/typescript/src/commands/game/sideQuest/sprite-powers.js

@@ -27,18 +27,28 @@
  * sprite type, and the five types' assignments account for all nine
  * exactly once -- the book's own list closes.
  *
- * WHAT THIS IS NOT. These are REFERENCE, not mechanics: no power below
- * is wired to a die roll in this engine yet, and `sprites.ts` says so
- * on the panel rather than implying otherwise. Listing an ability the
- * game cannot actually perform, without saying so, is the same defect
- * as a refusal naming a route that does not exist -- the game has paid
- * for that shape more than once. The listing answers "what is this
- * thing FOR", which is what was asked; it does not promise a verb.
+ * THIS TABLE IS NOW THE CATALOGUE BEHIND REAL VERBS (2026-09-15). It
+ * shipped as reference only -- "no power below is wired to a die roll in
+ * this engine yet", and sprites.ts said so on the panel rather than
+ * implying otherwise. Eight of the nine are moves you can type now:
+ * utilities/sprite-power-actions.ts resolves them, keyed off the same
+ * five sprite keys, so the panel and the mechanics cannot drift.
+ *
+ * STABILITY IS DELIBERATELY STILL REFERENCE, and `runnable` below is how
+ * each entry says which it is. Stability demotes glitches, and glitches
+ * are read at sixteen scattered sites in this engine (rest, climbing,
+ * haggling, barrier combat, hiring...). Wiring it at three of them would
+ * produce a power that works where someone happened to look and silently
+ * does nothing everywhere else -- which is exactly the "wrong ability on
+ * a sprite is worse than a missing one" case (CLAUDE.md). It wants the
+ * glitch contract changed in one place first, and that is its own piece
+ * of work.
  */
 /** All nine, alphabetical as the book lists them (p.256). */
 export const SPRITE_POWERS = [
     {
         key: 'camouflage',
+        runnable: true,
         name: 'Camouflage',
         effect: 'Hides a file inside another file, invisible to Matrix searches. Only a Matrix Perception Test specifically hunting the hidden file will turn it up -- and the sprite has to make that test too, to get its own file back out.',
         test: undefined,
@@ -46,6 +56,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'cookie',
+        runnable: true,
         name: 'Cookie',
         effect: 'Tags a persona with a silent tracking file rated at the sprite\'s Level. It logs every host entered, every program used, and who was talked to and when (not what was said). Net hits set the depth: one hit is a bare outline, four or more a detailed report. At a time set when it was placed the file ships itself back to the sprite -- and deletes itself instead if the sprite has left the Matrix. A Matrix Perception Test on the carrier finds it; unprotecting it and deleting it removes it.',
         test: 'Hacking + Resonance [Sleaze] v. Intuition + Firewall',
@@ -53,6 +64,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'diagnostics',
+        runnable: true,
         name: 'Diagnostics',
         effect: 'Reads a device down to its seams and helps somebody use or repair it, as a Teamwork Test. Any hits give +1 limit, and each hit adds a die to their pool. It takes the sprite\'s whole attention -- the bonus lasts until it drops the power or does anything else.',
         test: 'Simple Hardware + Level [Data Processing]',
@@ -60,6 +72,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'electron-storm',
+        runnable: true,
         name: 'Electron Storm',
         effect: 'Engulfs a persona in a sustained barrage of corrupting datastreams. On the first hit and on every action the sprite spends sustaining it, the target takes (Resonance) DV Matrix damage, resisted as normal, plus 2 points of noise. If the sprite takes any Matrix damage of its own, every storm it is sustaining ends at once.',
         test: 'Cybercombat + Resonance [Attack] v. Intuition + Firewall',
@@ -67,6 +80,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'gremlins',
+        runnable: true,
         name: 'Gremlins',
         effect: 'Makes a device misbehave -- a jammed control, a looped signal, a faulty reading. Success is a glitch; four or more net hits is a critical one, and the device crashes, burns out, or bites its user.',
         test: 'Hardware + Level [Attack] v. Device Rating + Firewall',
@@ -74,6 +88,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'hash',
+        runnable: true,
         name: 'Hash',
         effect: 'Seals a file with a Resonance algorithm only that sprite can undo, for up to (Level x 10) Combat Turns. Put the file down and it reverts to normal. Destroy the sprite while it still carries the file and the file is corrupted for good.',
         test: undefined,
@@ -81,6 +96,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'stability',
+        runnable: false,
         name: 'Stability',
         effect: 'Steadies any persona or device the sprite holds a mark on: standard glitches are ignored outright and critical glitches drop to standard. It stops induced accidents too, Gremlins included -- which is why a machine sprite can both cause and prevent them.',
         test: undefined,
@@ -88,6 +104,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'suppression',
+        runnable: true,
         name: 'Suppression',
         effect: 'Baffles a host into hesitating. A sprite using this inside a host delays any IC it launches by (Level / 2) Combat Turns, and delayed IC can neither act nor be targeted.',
         test: undefined,
@@ -95,6 +112,7 @@ export const SPRITE_POWERS = [
     },
     {
         key: 'watermark',
+        runnable: true,
         name: 'Watermark',
         effect: 'Marks an icon invisibly, readable only by Resonance-driven things -- a way to leave messages on Matrix objects that nobody else can see. A new watermark overwrites an old one, and it lasts as long as the icon does unless somebody erases the Matrix signature.',
         test: undefined,
@@ -108,6 +126,29 @@ export const SPRITE_POWER_SETS = [
     { spriteKey: 'fault', powers: ['electron-storm'], skills: ['Computer', 'Cybercombat', 'Hacking'], page: 'p.259' },
     { spriteKey: 'machine', powers: ['diagnostics', 'gremlins', 'stability'], skills: ['Computer', 'Electronic Warfare', 'Hardware'], page: 'p.259' },
 ];
+const MATRIX_BY_TYPE = {
+    data: l => ({ attack: l - 1, sleaze: l, dataProcessing: l + 4, firewall: l + 1 }),
+    fault: l => ({ attack: l + 3, sleaze: l, dataProcessing: l + 1, firewall: l + 2 }),
+    machine: l => ({ attack: l + 1, sleaze: l, dataProcessing: l + 3, firewall: l + 2 }),
+    crack: l => ({ attack: l, sleaze: l + 3, dataProcessing: l + 2, firewall: l + 1 }),
+    courier: l => ({ attack: l, sleaze: l + 3, dataProcessing: l + 1, firewall: l + 2 }),
+};
+export function spriteMatrix(spriteKey, level) {
+    const l = Math.max(1, level);
+    const build = MATRIX_BY_TYPE[spriteKey] ?? MATRIX_BY_TYPE.courier;
+    const attrs = build(l);
+    return {
+        attack: Math.max(0, attrs.attack),
+        sleaze: Math.max(0, attrs.sleaze),
+        dataProcessing: Math.max(0, attrs.dataProcessing),
+        firewall: Math.max(0, attrs.firewall),
+        resonance: l,
+    };
+}
+/** A sprite's Matrix condition monitor: 8 + (Level / 2) boxes (p.254). */
+export function spriteMatrixBoxes(level) {
+    return 8 + Math.floor(Math.max(1, level) / 2);
+}
 /** One power by key. */
 export function spritePower(key) {
     return SPRITE_POWERS.find(p => p.key === key);

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

@@ -952,6 +952,40 @@ export function factionFor(key) {
 export function catalogFactions() {
     return listOfKind('faction', factionFor);
 }
+/**
+ * AN NPC KIT ROW, rebuilt as the engine reads it (catalog v21, "everyone
+ * is basically naked"). Same contract as factionFor: the rows live on
+ * maka-cli.com, an unknown slug answers undefined, and npc-kits.ts
+ * treats that as "no kit" -- a cached catalog from before v21 builds
+ * NPCs exactly as the engine always did.
+ */
+export function npcKitFor(key) {
+    return kindIndex('npc-kit', row => {
+        const k = row.npcKit;
+        return {
+            key: row.slug,
+            name: row.name,
+            description: row.description,
+            professionalRating: k.professionalRating,
+            ...(k.faction !== undefined ? { faction: k.faction } : {}),
+            sort: k.sort,
+            attributes: { ...k.attributes },
+            skills: { ...k.skills },
+            gear: [...k.gear],
+            ...(k.ammo !== undefined ? { ammo: k.ammo } : {}),
+            augs: [...(k.augs ?? [])],
+            qualities: [...(k.qualities ?? [])],
+            spells: [...(k.spells ?? [])],
+            ...(k.adeptPowers !== undefined ? { adeptPowers: { ...k.adeptPowers } } : {}),
+            ...(k.lieutenant !== undefined ? { lieutenant: { ...k.lieutenant } } : {}),
+            page: row.page ?? '',
+        };
+    }).get(key);
+}
+/** Every NPC kit the resolved catalog knows. */
+export function catalogNpcKits() {
+    return listOfKind('npc-kit', npcKitFor);
+}
 /** Every metamagic and echo the resolved catalog knows. */
 export function catalogMetamagics() {
     return listOfKind('metamagic', metamagicFor);

package/bundle/typescript/src/commands/game/sideQuest/utilities/cleanup-errand.js

@@ -0,0 +1,67 @@
+/**
+ * PAYING SOMEBODY ELSE TO SCRUB THE FOOTAGE (user 2026-09-15: "I'd like
+ * 'cleanup' jobs to allow hiring a crew. This is for situations where the
+ * runner (say, Jynx -- street samurai) cannot access the matrix").
+ *
+ * THE HOLE THIS FILLS. A run that ends with live cameras leaves an
+ * ILooseEnd, and the hub nags about it every homecoming -- "Doc Wu's
+ * Clinic still has your face from 'Ash and Ledger'" -- while the only
+ * route it advertises is closed to most runners. `hop` needs a persona
+ * (commands/hop.ts), `jack in` needs a cyberdeck AND a direct neural
+ * interface (commands/jack.ts), and the cleanup scene is deliberately
+ * crew-free: "NO CLIENT, NO PAYOUT, NO NPCS" (factories/cleanup-seed.ts).
+ * So a street samurai was handed a consequence with no lever, and a
+ * +1 Public Awareness on a timer.
+ *
+ * WHY AN ERRAND AND NOT A CREW SEAT. The playable scene stays exactly as
+ * it is. Hiring a shadow decker through a fixer is the SR5 idiom, it
+ * respects the no-payout design (you PAY here -- there is no client to
+ * bill), and it does not need enterCleanup un-wired from the player or
+ * a crew member taught to cross into a Matrix scene. What it costs is
+ * nuyen and a little control: you are not there, so you do not get to
+ * roll for it.
+ *
+ * IT RIDES THE LOOSE END ITSELF (ILooseEnd.hired), which is already on
+ * the save -- so a hired errand survives a reload with no new save field
+ * and no SAVE_VERSION bump, and settleLooseEnds resolves it at the next
+ * homecoming like everything else on that record.
+ */
+/** What a scrub costs before haggling. */
+export function cleanupQuote(le) {
+    // A harder host is a harder job: the decker has to get through the same
+    // ice the runner would have. Rooms are how much footage there is to
+    // find. Round to something a fixer would actually say out loud.
+    const base = 1500 + (le.host.rating * 400) + (Math.max(1, le.rooms.length) * 250);
+    return Math.round(base / 100) * 100;
+}
+/**
+ * The decker's own test, rolled at the HOMECOMING rather than at hire
+ * time -- you paid for a result you do not get to watch.
+ *
+ * The pool is the fixer's reach (Connection) plus how much they care
+ * (Loyalty): a well-connected fixer knows a better decker, and one who
+ * likes you sends them sober. Against the host's rating, which is what
+ * the decker has to beat.
+ *
+ * LEVERAGE IS NOT A FAILURE. The file is gone either way; the difference
+ * is that somebody else now has a copy, which is a hook rather than a
+ * penalty -- the shadows run on favours owed.
+ */
+export function cleanupOutcome(netHits, criticalGlitch) {
+    if (criticalGlitch)
+        return 'botched';
+    if (netHits <= 0)
+        return 'botched';
+    return netHits >= 3 ? 'clean' : 'leverage';
+}
+/** The names a fixer's shadow decker answers to. Flavour, not mechanics. */
+export const SHADOW_DECKERS = ['Static', 'Nyx', 'Palimpsest', 'Ghostwrite', 'Null', 'Sundog'];
+export function pickShadowDecker(le) {
+    // Deterministic off the record's own id, so the quote and the job name
+    // the same person -- a fixer who offers "Static" does not send "Nyx".
+    let h = 0;
+    for (const ch of le.id)
+        h = (h * 31 + ch.charCodeAt(0)) >>> 0;
+    return SHADOW_DECKERS[h % SHADOW_DECKERS.length];
+}
+//# sourceMappingURL=cleanup-errand.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/cleanup-hire.js

@@ -0,0 +1,113 @@
+import { rollPool, formatRoll } from './dice.js';
+import { fuzzyPickName } from './fuzzy-match.js';
+import { cleanupQuote, pickShadowDecker } from './cleanup-errand.js';
+import { hint } from './hints.js';
+/**
+ * "ask <fixer> about cleanup" and "hire cleanup [<site>]" -- the two
+ * halves of paying somebody else to scrub your footage. The rules and
+ * pricing live in cleanup-errand.ts; this is the player-facing surface,
+ * kept out of both crew.ts and ask.ts because it belongs to neither.
+ */
+/** The best-placed contact to broker it: reach first, then how much they
+ *  like you. A fixer with no reach knows no deckers. */
+function brokerFor(game) {
+    let best;
+    for (const [name, c] of game.contacts.entries()) {
+        const score = c.connection * 2 + c.loyalty;
+        const bestScore = best ? best.connection * 2 + best.loyalty : -1;
+        if (score > bestScore)
+            best = { name, connection: c.connection, loyalty: c.loyalty };
+    }
+    return best;
+}
+/** The open loose end this request means -- named, or the freshest. */
+function pickLooseEnd(game, query) {
+    const open = game.looseEnds.filter(le => !le.hired);
+    if (open.length === 0)
+        return undefined;
+    if (!query)
+        return open[open.length - 1];
+    const picked = fuzzyPickName(query, open.map(le => le.site));
+    return picked ? open.find(le => le.site === picked) : undefined;
+}
+/**
+ * THE QUOTE (reached from "ask <contact> about cleanup"). No dice, no
+ * commitment, and no per-homecoming budget spent: this is a price, not
+ * legwork.
+ */
+export function cleanupQuoteFor(game, contactName, query = '') {
+    const le = pickLooseEnd(game, query);
+    if (!le) {
+        return game.looseEnds.length > 0
+            ? `"Already got someone on that one," ${contactName} says. "Sit tight."`
+            : `"Nothing of yours is sitting on anybody's host right now," ${contactName} says. "Enjoy it."`;
+    }
+    const contact = game.contacts.get(contactName);
+    if (!contact)
+        return undefined;
+    const decker = pickShadowDecker(le);
+    const price = cleanupQuote(le);
+    return [
+        `"${le.site}?" ${contactName} thinks about it. "Got a kid calls themselves ${decker} who scrubs feeds. `,
+        `Rating ${le.host.rating} host, ${le.rooms.length} room${le.rooms.length === 1 ? '' : 's'} of it -- ${price} nuyen and your face was never there."`,
+        hint(` ("hire cleanup${game.looseEnds.filter(l => !l.hired).length > 1 ? ` ${le.site}` : ''}" to send them in. Negotiation trims the price; the job lands when you next come home.)`),
+    ].join('');
+}
+/** THE HIRE: haggle, debit, stamp the record. The job itself resolves at
+ *  the next homecoming (Game.settleHiredCleanup). */
+export function hireCleanupErrand(actor, game, query, logger) {
+    const le = pickLooseEnd(game, query);
+    if (!le) {
+        const hiredAlready = game.looseEnds.some(le2 => le2.hired);
+        if (hiredAlready)
+            return `That one's already bought and paid for -- it lands when you next come home.`;
+        if (query)
+            return `Nothing of yours is sitting on a host called "${query}".`;
+        return `Nothing of yours is on anybody's host right now.${hint(` (A run that ends with the cameras still live leaves footage behind -- that is what this buys off.)`)}`;
+    }
+    const broker = brokerFor(game);
+    if (!broker) {
+        return `You don't know anybody who knows a decker.${hint(` (Contacts broker this -- trade with people, run their errands. "contacts" shows who talks to you.)`)}`;
+    }
+    const asking = cleanupQuote(le);
+    const decker = pickShadowDecker(le);
+    // ONE NEGOTIATION PASS, the same fence-counter school "hire" uses on a
+    // crew cut -- against the fixer's own Charisma-ish reach.
+    const negotiation = actor.skillRating('negotiation');
+    const mine = rollPool(Math.max(1, actor.charisma + (negotiation > 0 ? negotiation : -1)
+        + actor.socialRep + actor.bonus('social') + actor.woundModifier - actor.sustainingPenalty));
+    const theirs = rollPool(Math.max(1, broker.connection + 2));
+    const net = mine.hits - theirs.hits;
+    // A critical glitch talks the price UP -- you argued badly and they
+    // remembered it (the shape haggle.ts and hire already use).
+    const price = mine.criticalGlitch
+        ? Math.round(asking * 1.2 / 100) * 100
+        : Math.max(Math.round(asking * 0.6 / 100) * 100, asking - Math.max(0, net) * 200);
+    logger.meta(`Cleanup terms -- you (Cha + Negotiation): ${formatRoll(mine)}`);
+    logger.meta(`  ${broker.name} (Connection ${broker.connection}): ${formatRoll(theirs)} -- ${price} nuyen (asked ${asking})`);
+    if (actor.currency < price) {
+        return `${broker.name} names ${price} nuyen for ${le.site}. You're carrying ${actor.currency}.${hint(` (Nobody scrubs a host on credit.)`)}`;
+    }
+    actor.adjustCurrency(-price);
+    game.hireCleanup(le, {
+        fixer: broker.name,
+        price,
+        decker,
+        // Banked now so a loyalty shift before the homecoming cannot
+        // retroactively change a job already bought.
+        pool: broker.connection + broker.loyalty,
+    });
+    actor.performAction('hires a scrub', `${decker} on ${le.site}'s feeds`);
+    game.requestSave?.('cleanup');
+    const haggled = price < asking
+        ? `talked down from ${asking}`
+        : price > asking
+            ? `talked UP from ${asking} -- they didn't like your tone`
+            : `at the asking price`;
+    return [
+        `{light-blue-fg}${broker.name} makes one call and hangs up. "${decker}'s on it."{/light-blue-fg}`,
+        `\nYou slide ${price} nuyen across (${haggled}). ${actor.currency} left.`,
+        hint(` (Nothing to watch -- you're not the one going in. ${decker} reports back when you next come home from a job.)`),
+    ].join('');
+}
+//# sourceMappingURL=cleanup-hire.js.map