@maka/maka-cli 5.128.0 → 5.130.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.128.0",
+  "version": "5.130.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/archetypes.js

@@ -2,7 +2,7 @@ import { Player } from './models/player.js';
 import { Item } from './models/item.js';
 import { Size, Category, Rating } from './types/shared/item-enum.js';
 import { augFor } from './utilities/catalog.js';
-import { creationSplit, getQuality, CREATION_KARMA, KARMA_CARRYOVER_MAX, KARMA_TO_NUYEN_MAX, KARMA_NUYEN_RATE, HELD_NUYEN_MAX } from './qualities.js';
+import { creationSplit, getQuality, qualityKarma, CREATION_KARMA, KARMA_CARRYOVER_MAX, KARMA_TO_NUYEN_MAX, KARMA_NUYEN_RATE, HELD_NUYEN_MAX } from './qualities.js';
 import { catalogGearDef, catalogRowFor } from './utilities/catalog.js';
 export const ARCHETYPES = [
     {
@@ -103,6 +103,9 @@ export const ARCHETYPES = [
             adeptPowers: { 'improved-reflexes': 1, 'killing-hands': 1 },
             skills: { spellcasting: 5, counterspelling: 3, assensing: 3, unarmed: 4, blades: 3, gymnastics: 3, running: 3, swimming: 2, perception: 3, sneaking: 3, pistols: 2 } },
         qualities: ['focused-concentration', 'mentor-spirit', 'astral-beacon'],
+        // Rating 2 (p.74, 4 karma a rating): a Force 2 working held free.
+        // The ledger above priced rating 1; each rating past it is 4 more.
+        qualityRatings: { 'focused-concentration': 2 },
         gearSlugs: [
             'power-focus-1', 'reagents', 'armor-jacket', 'combat-boots', 'meta-link',
             'medkit-3', 'trauma-patch', 'stim-patch', 'ear-buds', 'glasses',
@@ -203,6 +206,9 @@ export const ARCHETYPES = [
         // into their dreams and calls it rent. Ledger 25 - 7 + 10 = 28 -> 7
         // karma + 20,000 nuyen.
         qualities: ['high-pain-tolerance', 'focused-concentration', 'mentor-spirit', 'quick-healer', 'insomnia'],
+        // Rating 2 (p.74, 4 karma a rating): a Force 2 working held free.
+        // The ledger above priced rating 1; each rating past it is 4 more.
+        qualityRatings: { 'focused-concentration': 2 },
         gearSlugs: [
             // A formula for a spell they do NOT know: that is what a formula
             // is for. Same 2,000 as the Combat category row it replaces, so
@@ -263,6 +269,10 @@ export const ARCHETYPES = [
         // who never let them look at the other half.
         // Ledger 25 - 9 = 16 -> 7 karma + 18,000 nuyen.
         qualities: ['focused-concentration', 'mentor-spirit'],
+        // Rating 3 (p.74, 4 karma a rating): the pure spellslinger holds a
+        // drain-neutral Force 3 working free -- Increase Reflexes, a barrier.
+        // The ledger above priced rating 1; each rating past it is 4 more.
+        qualityRatings: { 'focused-concentration': 3 },
         gearSlugs: [
             // Was Combat + Detection + Health category formulae (2,000 + 500
             // + 500). The Detection one was for a category this engine has no
@@ -294,6 +304,9 @@ export const ARCHETYPES = [
         // The spirits like them, which is not the same as the spirits being
         // safe. Ledger 25 - 11 = 14 -> 7 karma + 14,000 nuyen.
         qualities: ['spirit-affinity', 'focused-concentration'],
+        // Rating 2 (p.74, 4 karma a rating): a Force 2 working held free.
+        // The ledger above priced rating 1; each rating past it is 4 more.
+        qualityRatings: { 'focused-concentration': 2 },
         gearSlugs: [
             'spirit-focus-1', 'power-focus-1', 'lodge-materials-3',
             'reagents', 'transys-avalon', 'medkit-6',
@@ -360,6 +373,10 @@ export const ARCHETYPES = [
         // taxman never stops collecting. Ledger 25 - 5 + 15 = 35 -> 7 karma
         // + 20,000 nuyen (the rest went into that resonance).
         qualities: ['analytical-mind', 'natural-hardening', 'prime-datahaven-membership', 'focused-concentration', 'sinner-corp'],
+        // Rating 2 (p.74, 4 karma a rating): a Level 2 complex form held
+        // free -- the quality covers a form exactly as it covers a spell.
+        // The ledger above priced rating 1; each rating past it is 4 more.
+        qualityRatings: { 'focused-concentration': 2 },
         gearSlugs: [
             'armor-jacket', 'combat-boots', 'fake-sin-4', 'meta-link',
             'microtransceiver', 'data-tap', 'micro-camera', 'stealth-tags',
@@ -426,7 +443,10 @@ export function archetypeLedger(archetype) {
     const augNuyen = (archetype.augs ?? []).reduce((n, key) => n + (augFor(key)?.cost ?? 0), 0);
     const spent = (archetype.qualities ?? []).reduce((n, key) => {
         const q = getQuality(key);
-        return n + (q ? (q.kind === 'positive' ? q.karma : -q.karma) : 0);
+        if (!q)
+            return n;
+        const cost = qualityKarma(q, archetype.qualityRatings?.[key]);
+        return n + (q.kind === 'positive' ? cost : -cost);
     }, 0) + (archetype.combat.powerPoints ?? 0) * 5;
     const karmaRemainder = CREATION_KARMA - spent;
     const karmaConverted = Math.min(Math.max(0, karmaRemainder - KARMA_CARRYOVER_MAX), KARMA_TO_NUYEN_MAX);
@@ -523,7 +543,7 @@ export function outfitArchetype(player, archetype) {
         player.picks.set(key, pick);
     }
     for (const key of archetype.qualities ?? []) {
-        player.addQuality(key);
+        player.addQuality(key, archetype.qualityRatings?.[key]);
     }
     // Power Points ride the SAME pool (SR5 p.69-70, 5 karma each): a mystic
     // adept archetype pays for its points exactly as a web-built one does.
@@ -531,6 +551,7 @@ export function outfitArchetype(player, archetype) {
     // exactly as before.
     const split = creationSplit({
         qualities: archetype.qualities ?? [],
+        qualityRatings: archetype.qualityRatings,
         powerPoints: archetype.combat.powerPoints ?? 0,
     });
     player.karma += split.karma;

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

@@ -1,3 +1,4 @@
+import { sustainBurden } from '../utilities/sustaining.js';
 import { BypassCommand } from './bypass-command.js';
 import { hint } from '../utilities/hints.js';
 import { CombatExchange } from '../utilities/combat-exchange.js';
@@ -776,15 +777,20 @@ export class CastCommand extends BypassCommand {
             return error ?? `You don't see them here.`;
         const self = target === this.actor;
         // Sustained toggle per bearer: casting at them again unravels it, no
-        // drain to let go. (The caster is the only one who can release it --
-        // a mundane bearer has no way to drop a spell themselves.)
+        // drain to let go. The caster is the only one who can release it
+        // (p.282: the caster sustains) -- a weave somebody ELSE is holding
+        // on them is that caster's to drop, not yours to overwrite.
         if (target.sustainedArmor > 0) {
+            const holder = target.wornSpellCaster('armor');
+            if (holder && holder !== this.actor) {
+                return `${holder.name} is holding an armor weave on ${self ? 'you' : target.name} already -- only ${holder.name} can let it go.`;
+            }
             target.setSustainedArmor(0);
             this.scene.updateStatus();
             this.actor.performAction('releases armor spell', self ? '' : `on ${target.name}`);
             return this.finishSpell([self
                     ? `You let the armor spell go. The air stops humming, and the sustaining penalty lifts.`
-                    : `You unravel the armor weave around ${target.name}. The shimmer fades, and their sustaining burden lifts.`]);
+                    : `You unravel the armor weave around ${target.name}. The shimmer fades, and the burden of holding it lifts from you.`]);
         }
         if (target.isIncapacitated()) {
             return `${target.name} is down -- armor won't help now.`;
@@ -794,16 +800,20 @@ export class CastCommand extends BypassCommand {
         const focus = this.actor.getBestFocus();
         const bonus = Math.ceil(force / 3) + (focus?.ratingValue ?? 0); // the focus's Force (catalog v13)
         const spell = spellFor('armor');
-        // The weave taxes its BEARER: they get the soak and carry the -2
-        // sustaining burden. The caster pays only the drain.
+        // The BEARER wears the weave (the soak is theirs); the CASTER
+        // sustains it and carries the -2 (p.282), on top of the drain.
         target.setSustainedArmor(bonus);
         target.noteSustainedForce('armor', force);
+        target.sustainedBy('armor', this.actor);
         this.actor.performAction('casts armor', self ? '' : `on ${target.name}`);
         this.scene.addWorldEvent(`${this.actor.name} wrapped ${self ? 'themselves' : target.name} in a shimmering armor spell.`);
         this.scene.updateStatus();
+        // The burden is the CASTER's ledger's, not a restated -2: a Focused
+        // Concentration holder is told "no penalty" the moment it applies.
+        const burden = sustainBurden(this.actor.sustainedLedger().find(w => w.key === 'armor' && (self ? w.bearer === undefined : w.bearer === target.name)), ' to everything else you do');
         const lines = [
             `${this.actor.name} casts armor at Force ${force}${self ? '' : ` on ${target.name}`}, ${this.castingLabel()}:`,
-            `  The air hardens around ${self ? 'you' : target.name} -- +${bonus} soak dice while sustained, -2 dice to everything else ${self ? 'you do' : 'they do'}.`,
+            `  The air hardens around ${self ? 'you' : target.name} -- +${bonus} soak dice while sustained${self ? '' : '; you hold the weave up'}, ${burden}.`,
             hint(`  (Cast armor${self ? '' : ` on ${target.name}`} again to release it.)`),
             ...this.applyDrain(spell, force, overcast),
         ];
@@ -864,11 +874,12 @@ export class CastCommand extends BypassCommand {
             ? `${actor.name} wove a mana barrier across the way ${direction} in ${room.name}.`
             : `${actor.name} raised a shimmering force barrier across the way ${direction} in ${room.name}.`);
         this.scene.updateStatus();
+        const burden = sustainBurden(actor.sustainedLedger().find(w => w.key === spellKey), ' to everything else you do');
         const lines = [
             `${actor.name} casts ${mana ? 'mana barrier' : 'barrier'} at Force ${force}, ${this.castingLabel()}:`,
             mana
-                ? `  A lattice of woven mana settles across the way ${direction} -- invisible to meat eyes, Force ${force}. SPIRITS and astral forms stop at it; the living walk through without noticing. -2 dice to everything else you do.`
-                : `  The air itself hardens across the way ${direction} -- a faint heat-shimmer wall, Force ${force}. NOBODY passes while you hold it (you included), and -2 dice to everything else you do.`,
+                ? `  A lattice of woven mana settles across the way ${direction} -- invisible to meat eyes, Force ${force}. SPIRITS and astral forms stop at it; the living walk through without noticing. ${burden.charAt(0).toUpperCase()}${burden.slice(1)}.`
+                : `  The air itself hardens across the way ${direction} -- a faint heat-shimmer wall, Force ${force}. NOBODY passes while you hold it (you included), and ${burden}.`,
             hint(`  (Cast ${spellKey} again to release it; "dispel ${mana ? 'mana barrier' : 'barrier'}" unweaves it from either side.)`),
             ...this.applyDrain(spell, force, overcast),
         ];
@@ -877,8 +888,8 @@ export class CastCommand extends BypassCommand {
     }
     /**
      * The sustained utility pair (invisibility / increase reflexes), same
-     * toggle shape as the armor spell: the BEARER carries the effect and
-     * its -2 sustaining burden, the caster pays the drain, and casting at
+     * toggle shape as the armor spell: the BEARER wears the effect, the
+     * CASTER sustains it (-2, p.282) and pays the drain, and casting at
      * the same bearer again releases it for free.
      */
     async castSustainedUtility(spellKey, force, overcast, rest = []) {
@@ -889,12 +900,16 @@ export class CastCommand extends BypassCommand {
         const flag = spellKey === 'invisibility' ? 'sustainedInvisibility' : 'sustainedReflexes';
         const label = spellKey === 'invisibility' ? 'invisibility' : 'increase reflexes';
         if (target[flag]) {
+            const holder = target.wornSpellCaster(spellKey);
+            if (holder && holder !== this.actor) {
+                return `${holder.name} is holding ${label} on ${self ? 'you' : target.name} already -- only ${holder.name} can let it go.`;
+            }
             target[flag] = false;
             this.scene.updateStatus();
             this.actor.performAction(`releases ${label}`, self ? '' : `on ${target.name}`);
             return this.finishSpell([spellKey === 'invisibility'
-                    ? `${self ? 'You shimmer back into the world' : `${target.name} shimmers back into the world`} -- the light remembers ${self ? 'you' : 'them'}, and the sustaining burden lifts.`
-                    : `${self ? 'Your' : `${target.name}'s`} nerves cool back to human speed. The sustaining burden lifts.`]);
+                    ? `${self ? 'You shimmer back into the world' : `${target.name} shimmers back into the world`} -- the light remembers ${self ? 'you' : 'them'}, and the sustaining burden lifts${self ? '' : ' from you'}.`
+                    : `${self ? 'Your' : `${target.name}'s`} nerves cool back to human speed. The sustaining burden lifts${self ? '' : ' from you'}.`]);
         }
         if (target.isIncapacitated()) {
             return `${target.name} is down -- ${label} won't help now.`;
@@ -906,14 +921,18 @@ export class CastCommand extends BypassCommand {
         const spell = spellFor(spellKey);
         target[flag] = true;
         target.noteSustainedForce(spellKey, force);
+        target.sustainedBy(spellKey, this.actor);
         this.actor.performAction(`casts ${label}`, self ? '' : `on ${target.name}`);
         this.scene.addWorldEvent(spellKey === 'invisibility'
             ? `${this.actor.name} wove an invisibility spell${self ? '' : ` over ${target.name}`}.`
             : `${this.actor.name} cast increase reflexes${self ? '' : ` on ${target.name}`}.`);
         this.scene.updateStatus();
+        // The CASTER's ledger: they hold it, they pay (p.282).
+        const burden = sustainBurden(this.actor.sustainedLedger().find(w => w.key === spellKey && (self ? w.bearer === undefined : w.bearer === target.name)), ' to everything else you do');
+        const holding = self ? '' : '; you hold it up';
         const effectLine = spellKey === 'invisibility'
-            ? `  The light slides around ${self ? 'you' : target.name} like water around a stone -- +3 dice on sneak contests while sustained, -2 dice to everything else ${self ? 'you do' : 'they do'}. Loud acts still announce ${self ? 'you' : 'them'}.`
-            : `  ${self ? 'Your' : `${target.name}'s`} nerves run HOT -- +2 initiative while sustained, -2 dice to everything else ${self ? 'you do' : 'they do'}.`;
+            ? `  The light slides around ${self ? 'you' : target.name} like water around a stone -- +3 dice on sneak contests while sustained${holding}, ${burden}. Loud acts still announce ${self ? 'you' : 'them'}.`
+            : `  ${self ? 'Your' : `${target.name}'s`} nerves run HOT -- +2 initiative while sustained${holding}, ${burden}.`;
         const lines = [
             `${this.actor.name} casts ${label} at Force ${force}${self ? '' : ` on ${target.name}`}, ${this.castingLabel()}:`,
             effectLine,

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

@@ -3,11 +3,13 @@ import { hint } from '../utilities/hints.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { catalogMetamagics } from '../utilities/catalog.js';
 // THE PICKS ARE CATALOG ROWS (kind 'metamagic' on maka-cli.com), read
-// through catalogMetamagics(); the shape is ../metamagics.ts. The five
-// metamagics whose rule is not expressible as dice (quickening,
-// overclocking, the two Matrix upgrades, power-point) are keyed by name
-// in models/player.ts -- a row with a new key does nothing until the
-// engine grows a seat for it.
+// through catalogMetamagics(); the shape is ../metamagics.ts. The four
+// metamagics whose rule is not expressible as dice (overclocking, the
+// two Matrix upgrades, power-point) are keyed by name in
+// models/player.ts -- a row with a new key does nothing until the
+// engine grows a seat for it. Quickening left that list on 2026-09-06:
+// its row carries a `sustain` effect (utilities/effects.ts) and the
+// engine reads that, not the slug.
 export class InitiateCommand extends Command {
     static verb = 'initiate';
     static description = 'Initiation/submersion at your hideout (10 + grade x3 karma): each grade lifts Magic/Resonance past 6 and grants a metamagic (or echo). "initiate" lists; "initiate <pick>" pays.';

package/bundle/typescript/src/commands/game/sideQuest/commands/quality-trade.js

@@ -19,7 +19,7 @@ const onSale = () => catalogQualities().filter(q => !q.retired);
  */
 export class QualityTradeCommand extends Command {
     static verb = 'qualities';
-    static description = 'Trade qualities with karma at your hideout (SR5e x2 rates): "qualities" lists, "qualities <name>" buys a positive or buys off a negative.';
+    static description = 'Trade qualities with karma at your hideout (SR5e x2 rates): "qualities" lists, "qualities <name>" buys a positive or buys off a negative; "qualities <name> <rating>" buys or raises a rated one.';
     async execute(args = []) {
         const actor = this.actor;
         if (actor.inExchange) {
@@ -34,10 +34,19 @@ export class QualityTradeCommand extends Command {
         if (!args || args.length === 0) {
             return this.listBoard();
         }
+        // A trailing number is the RATING wanted for a rated quality
+        // ("qualities focused concentration 3"); everything before it names
+        // the quality. Parsed off first so the name match never sees it.
+        let words = [...args];
+        let wanted;
+        if (words.length > 1 && /^\d+$/.test(words[words.length - 1])) {
+            wanted = parseInt(words[words.length - 1], 10);
+            words = words.slice(0, -1);
+        }
         // Exact key first ("qualities sinner-criminal" works verbatim), then
         // fuzzy over display names ONLY -- names and keys together made every
         // single-word quality ambiguous with its own key.
-        const input = args.join(' ');
+        const input = words.join(' ');
         const byKey = onSale().find(q => q.key === input.toLowerCase().replace(/\s+/g, '-'));
         const picked = byKey?.name ?? fuzzyPickName(input, onSale().map(q => q.name));
         const quality = onSale().find(q => q.name === picked);
@@ -45,30 +54,55 @@ export class QualityTradeCommand extends Command {
             return `That's not a quality this street knows. "qualities" lists the board.`;
         }
         if (quality.kind === 'positive') {
-            return this.buyPositive(quality);
+            return this.buyPositive(quality, wanted);
         }
         return this.buyOffNegative(quality);
     }
-    buyPositive(quality) {
+    /**
+     * A RATED quality (IQuality.maxRating) is bought at a rating and
+     * priced per rating (p.74 Focused Concentration: 4 karma a rating, x2
+     * in play), and a holder may RAISE one by paying for the ratings they
+     * do not yet have. Until 2026-09-06 this verb bought every quality at
+     * rating 1 and refused to touch it again, so Focused Concentration
+     * bought here covered a Force 1 spell for the rest of the character's
+     * life.
+     */
+    buyPositive(quality, wanted) {
         const actor = this.actor;
-        if (actor.hasQuality(quality.key)) {
-            return `${quality.name} is already part of who you are.`;
+        const held = actor.hasQuality(quality.key) ? actor.qualityRating(quality.key) : 0;
+        if (!quality.maxRating) {
+            if (held > 0)
+                return `${quality.name} is already part of who you are.`;
+            if (wanted !== undefined)
+                return `${quality.name} takes no rating -- "qualities ${quality.key}" alone buys it.`;
+        }
+        const rating = quality.maxRating ? Math.max(1, Math.floor(wanted ?? (held > 0 ? held + 1 : 1))) : 1;
+        if (quality.maxRating && rating > quality.maxRating) {
+            return `${quality.name} tops out at rating ${quality.maxRating}${hint(` (${quality.page})`)}.`;
+        }
+        if (quality.maxRating && rating <= held) {
+            return `You already hold ${quality.name} at rating ${held}${hint(` -- "qualities ${quality.key} ${held + 1}" raises it`)}.`;
         }
         // RAW forbids the one stacking this catalog can produce: High Pain
         // Tolerance never combines with a pain editor (p.74).
         if (quality.key === 'high-pain-tolerance' && actor.hasAug('pain-editor')) {
             return `The pain editor already owns that circuit -- High Pain Tolerance can't grow where chrome filters first${hint(' (SR5e p.74)')}.`;
         }
-        const cost = quality.karma * 2;
+        // Per rating, for the ratings not yet held: raising 2 -> 4 pays for
+        // two, not four.
+        const cost = quality.karma * (rating - held) * 2;
+        const label = quality.maxRating ? `${quality.name} ${rating}` : quality.name;
         if (actor.karma < cost) {
-            return `${quality.name} costs ${cost} karma in play${hint(` (listed ${quality.karma} x2, ${quality.page})`)} -- you have ${actor.karma}.`;
+            return `${label} costs ${cost} karma in play${hint(` (listed ${quality.karma}${quality.maxRating ? ' a rating' : ''} x2, ${quality.page})`)} -- you have ${actor.karma}.`;
         }
         actor.karma -= cost;
-        actor.addQuality(quality.key);
-        this.actor.performAction('grows into', quality.name);
-        this.logger.write(`${actor.name} bought quality ${quality.key} (${cost} karma, ${actor.karma} left).`);
+        actor.addQuality(quality.key, rating);
+        this.actor.performAction(held > 0 ? 'deepens' : 'grows into', label);
+        this.logger.write(`${actor.name} bought quality ${quality.key}${quality.maxRating ? ` at rating ${rating}` : ''} (${cost} karma, ${actor.karma} left).`);
         this.scene.updateStatus();
-        return `It took the downtime to make it true, but it's true now: ${quality.name}. ${quality.effect}. (${cost} karma spent, ${actor.karma} left.)`;
+        return held > 0
+            ? `The discipline deepens: ${label}. ${quality.effect}. (${cost} karma spent, ${actor.karma} left.)`
+            : `It took the downtime to make it true, but it's true now: ${label}. ${quality.effect}. (${cost} karma spent, ${actor.karma} left.)`;
     }
     buyOffNegative(quality) {
         const actor = this.actor;
@@ -106,10 +140,14 @@ export class QualityTradeCommand extends Command {
         if (owned.length > 0) {
             lines.push(`Yours:`);
             for (const q of owned) {
+                const held = actor.qualityRating(q.key);
                 const trade = q.kind === 'negative'
                     ? `  buy off for ${q.karma * 2} karma${actor.karma >= q.karma * 2 ? '' : ' (short)'}`
-                    : ` (yours to keep)`;
-                lines.push(`  ${(q.kind === 'positive' ? '+ ' : '- ') + q.name.padEnd(24)} ${q.effect}${trade}`);
+                    : q.maxRating && held < q.maxRating
+                        ? ` (rating ${held} of ${q.maxRating} -- ${q.karma * 2} karma a rating to raise)`
+                        : ` (yours to keep)`;
+                const name = q.maxRating ? `${q.name} ${held}` : q.name;
+                lines.push(`  ${(q.kind === 'positive' ? '+ ' : '- ') + name.padEnd(24)} ${q.effect}${trade}`);
             }
         }
         const buyable = onSale().filter(q => q.kind === 'positive' && !actor.hasQuality(q.key));
@@ -117,7 +155,7 @@ export class QualityTradeCommand extends Command {
             lines.push(`On the board${hint(' (listed x2 to learn in play)')}:`);
             for (const q of buyable) {
                 const blocked = q.key === 'high-pain-tolerance' && actor.hasAug('pain-editor');
-                lines.push(`  + ${q.name.padEnd(24)} ${q.effect} -- ${q.karma * 2} karma${blocked ? ' (BLOCKED: pain editor)' : actor.karma >= q.karma * 2 ? '' : ' (short)'}`);
+                lines.push(`  + ${q.name.padEnd(24)} ${q.effect} -- ${q.karma * 2} karma${q.maxRating ? ` a rating (to ${q.maxRating})` : ''}${blocked ? ' (BLOCKED: pain editor)' : actor.karma >= q.karma * 2 ? '' : ' (short)'}`);
             }
         }
         const footer = hint(`"qualities <name>" buys a positive or buys off a negative. Negatives can't be taken on for karma -- the street hands those out for free (see your sheet's Stains).`);

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

@@ -1,3 +1,4 @@
+import { sustainBurden } from '../utilities/sustaining.js';
 import { Command } from './command.js';
 import { homeGrid } from '../utilities/grids.js';
 import { getAspect } from '../aspects.js';
@@ -172,7 +173,7 @@ export class SheetCommand extends Command {
             ...(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`)] : []),
-            ...(a.sustainedArmor > 0 ? [row('Sustained', `armor +${a.sustainedArmor} soak (-2 dice)`)] : []),
+            ...(a.sustainedArmor > 0 ? [row('Sustained', `armor +${a.sustainedArmor} soak (${a.wornSpellCaster('armor') ? `held by ${a.wornSpellCaster('armor').name}` : sustainBurden(a.sustainedLedger().find(w => w.key === 'armor' && w.bearer === undefined))})`)] : []),
         ];
         return lines.join('\n');
     }

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

@@ -1,3 +1,4 @@
+import { sustainBurden } from '../utilities/sustaining.js';
 import { Command } from './command.js';
 import { Category } from '../types/shared/item-enum.js';
 import { hint } from '../utilities/hints.js';
@@ -66,20 +67,36 @@ export class SpellsCommand extends Command {
         // The sustained STATE is data; the release coaching is a hint
         // (player ruling: the spellbook's reference facts stay, its
         // tutorials go behind the hints toggle).
+        // The cost per working is the engine's (Player.sustainedLedger): a
+        // Focused Concentration holder reads "no penalty" here, not a
+        // restated -2.
+        // The CASTER pays (p.282): a spell somebody else holds on you shows
+        // as worn, with the holder named; what you hold on others is listed
+        // after, with its bearer.
+        const ledger = actor.sustainedLedger();
+        const burden = (key) => {
+            const holder = actor.wornSpellCaster(key);
+            return holder ? `held by ${holder.name} -- their burden` : sustainBurden(ledger.find(w => w.key === key && w.bearer === undefined), ' to everything else');
+        };
         if (actor.sustainedArmor > 0) {
-            lines.push(`Sustained: armor spell, +${actor.sustainedArmor} soak (-2 dice to everything else).${hint(' Cast armor again to release.')}`);
+            lines.push(`Sustained: armor spell, +${actor.sustainedArmor} soak (${burden('armor')}).${hint(' Cast armor again to release.')}`);
         }
         if (actor.sustainedInvisibility) {
-            lines.push(`Sustained: invisibility, +3 on sneak contests (-2 dice to everything else).${hint(' Cast invisibility again to release.')}`);
+            lines.push(`Sustained: invisibility, +3 on sneak contests (${burden('invisibility')}).${hint(' Cast invisibility again to release.')}`);
+        }
+        for (const w of ledger) {
+            if (w.bearer === undefined)
+                continue;
+            lines.push(`Sustaining on ${w.bearer}: ${w.key === 'reflexes' ? 'increase reflexes' : w.key} (${sustainBurden(w, ' to everything else')}).${hint(` Cast ${w.key} on ${w.bearer} again to release.`)}`);
         }
         if (actor.sustainedBarrier) {
-            lines.push(`Sustained: force barrier sealing ${actor.sustainedBarrier.direction} in ${actor.sustainedBarrier.roomName}, Force ${actor.sustainedBarrier.force} (-2 dice to everything else).${hint(' Cast barrier again to release.')}`);
+            lines.push(`Sustained: force barrier sealing ${actor.sustainedBarrier.direction} in ${actor.sustainedBarrier.roomName}, Force ${actor.sustainedBarrier.force} (${burden('barrier')}).${hint(' Cast barrier again to release.')}`);
         }
         if (actor.sustainedManaBarrier) {
-            lines.push(`Sustained: mana barrier sealing ${actor.sustainedManaBarrier.direction} in ${actor.sustainedManaBarrier.roomName}, Force ${actor.sustainedManaBarrier.force} (-2 dice to everything else).${hint(' Cast manabarrier again to release.')}`);
+            lines.push(`Sustained: mana barrier sealing ${actor.sustainedManaBarrier.direction} in ${actor.sustainedManaBarrier.roomName}, Force ${actor.sustainedManaBarrier.force} (${burden('manabarrier')}).${hint(' Cast manabarrier again to release.')}`);
         }
         if (actor.sustainedReflexes) {
-            lines.push(`Sustained: increase reflexes, +2 initiative (-2 dice to everything else).${hint(' Cast it again to release.')}`);
+            lines.push(`Sustained: increase reflexes, +2 initiative (${burden('reflexes')}).${hint(' Cast it again to release.')}`);
         }
         // The spells themselves -- only what this actor actually knows.
         // Grouped RAW-style (p.283-293): combat's direct/indirect split is

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

@@ -1,3 +1,4 @@
+import { sustainTotal } from '../utilities/sustaining.js';
 import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
@@ -93,14 +94,17 @@ export class SustainCommand extends Command {
                     // "Machine Sprite (Level 1) (Level 1)". Caught on a bench --
                     // the kind of thing that reads as a rendering bug and gets
                     // the whole item bounced.
-                    lines.push(`  ${h.npc.name} holds ${h.npc.sustainedForms.map(f => f.key).join(', ')} -- ${h.npc.sustainedForms.length * 2} dice off THEIR pools, none off yours.`);
+                    lines.push(`  ${h.npc.name} holds ${h.npc.sustainedForms.map(f => f.key).join(', ')} -- ${h.npc.sustainedLedger().filter(w => w.kind === 'form').reduce((n, w) => n + w.cost, 0)} dice off THEIR pools, none off yours.`);
                 }
             }
             if (mine.length === 0 && lines.length === 0) {
                 return `You hold no complex forms, and nothing of yours is holding one for you.${hint(` ("thread <form>" weaves one.)`)}`;
             }
+            // The cost is the engine's (Player.sustainedLedger): Focused
+            // Concentration covers a complex form exactly as it covers a spell
+            // (p.74), and this line says so rather than restating -2.
             const yours = mine.length > 0
-                ? `You are sustaining ${mine.map(f => f.key).join(', ')} yourself -- ${mine.length * 2} dice off everything you do.`
+                ? `You are sustaining ${mine.map(f => f.key).join(', ')} yourself -- ${sustainTotal(actor.sustainedLedger().filter(w => w.kind === 'form'), ' off everything you do')}.`
                 : `You are sustaining nothing yourself.`;
             const offer = mine.length > 0 && sprites.length > 0
                 ? hint(`\n("sustain <form>" hands one to a registered sprite for a task.)`)

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

@@ -1,3 +1,4 @@
+import { sustainBurden, sustainTotal } from '../utilities/sustaining.js';
 import { Command } from './command.js';
 import { matrixConstructsInReach } from '../utilities/matrix-roster.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
@@ -69,7 +70,7 @@ export class ThreadCommand extends Command {
                 lines.push(`  ${f.name.padEnd(16)} ${f.kind === 'sustained' ? '[sustained]' : '[instant]  '} ${f.blurb}${held ? ' {cyan-fg}(HELD){/cyan-fg}' : ''}`);
             }
             if (actor.sustainedForms.length > 0) {
-                lines.push('', `  Holding ${actor.sustainedForms.length} form${actor.sustainedForms.length === 1 ? '' : 's'} (-${actor.sustainedForms.length * 2} dice).${hint(` ("thread drop <form>" releases.)`)}`);
+                lines.push('', `  Holding ${actor.sustainedForms.length} form${actor.sustainedForms.length === 1 ? '' : 's'} (${sustainTotal(actor.sustainedLedger().filter(w => w.kind === 'form'))}).${hint(` ("thread drop <form>" releases.)`)}`);
             }
             return lines.join('\n');
         }
@@ -310,7 +311,8 @@ export class ThreadCommand extends Command {
                 // how ambitious it was and not how well it went.
                 actor.sustainedForms.push({ key: form.key, level, hits });
                 const effect = form.key === 'diagnostics' ? '+2 to your Matrix pools' : '+2 Matrix defense';
-                return [`  ${form.name} settles over your persona and HOLDS -- ${effect} while you sustain it (-2 dice to everything else).${hint(` ("thread drop ${form.key}" releases.)`)}`];
+                const burden = sustainBurden(actor.sustainedLedger().find(w => w.key === form.key), ' to everything else');
+                return [`  ${form.name} settles over your persona and HOLDS -- ${effect} while you sustain it (${burden}).${hint(` ("thread drop ${form.key}" releases.)`)}`];
             }
             default:
                 return [`  The form resolves and fades.`];

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

@@ -1,3 +1,4 @@
+import { sustainBurden, sustainTotal } from './utilities/sustaining.js';
 import { agentRatingFromName } from './utilities/programs.js';
 import { MATRIX_STANCE_ACTION } from './models/player.js';
 import { buildDossierUrl } from './utilities/web-character-generator.js';
@@ -5276,8 +5277,20 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         lines.push(`${armorNote}${arSlot}  |  ${link}  |  ${docwagon}`);
         // Lines 4+: transient states, present only while active. Future
         // contexts (astral projection, VR hot-sim) join here the same way.
+        // THE COST IS THE ENGINE'S. Every one of these lines printed a
+        // literal -2 until 2026-09-06, while sustainingPenalty was already
+        // waiving a Focused Concentration holder's spell -- the HUD told the
+        // player they were paying for what the pools were not charging.
+        //
+        // THE CASTER PAYS (p.282, 2026-09-06). A spell somebody else holds
+        // on this character is on their sheet as WORN -- soak and all --
+        // with the holder named and no cost; what this character holds on
+        // others rides the ledger below with its bearer named.
+        const ledger = player.sustainedLedger();
+        const heldBy = (key) => player.wornSpellCaster(key)?.name;
         if (player.sustainedArmor > 0) {
-            lines.push(`{magenta-fg}Sustained: armor +${player.sustainedArmor} soak (-2 dice to everything else){/magenta-fg}`);
+            const holder = heldBy('armor');
+            lines.push(`{magenta-fg}Sustained: armor +${player.sustainedArmor} soak (${holder ? `held by ${holder} -- their burden` : sustainBurden(ledger.find(w => w.key === 'armor' && w.bearer === undefined), ' to everything else')}){/magenta-fg}`);
         }
         // THE MAGE'S HALF OF THE SAME QUESTION (TNf9WrZGxCmCzqA4L, scope
         // completed by ruling).
@@ -5303,10 +5316,11 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // Naming it belongs with the condition monitors if it belongs
         // anywhere; that is a separate call and not this item's.
         const heldSpells = [];
+        const worn = (label, key) => heldSpells.push(heldBy(key) ? `${label} (held by ${heldBy(key)})` : label);
         if (player.sustainedInvisibility)
-            heldSpells.push('invisibility');
+            worn('invisibility', 'invisibility');
         if (player.sustainedReflexes)
-            heldSpells.push('increased reflexes');
+            worn('increased reflexes', 'reflexes');
         // The barriers say WHERE, because a wall you forgot you put up is
         // the one that strands the team -- and both of them seal an exit
         // that the caster cannot pass either.
@@ -5316,8 +5330,15 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         if (player.sustainedManaBarrier) {
             heldSpells.push(`mana barrier (${player.sustainedManaBarrier.roomName} ${player.sustainedManaBarrier.direction})`);
         }
+        // What this character holds on OTHERS -- the caster's burden, named
+        // by bearer so the mage knows whose armor is costing them two dice.
+        for (const w of ledger) {
+            if (w.bearer !== undefined)
+                heldSpells.push(`${w.key === 'reflexes' ? 'increased reflexes' : w.key} on ${w.bearer}`);
+        }
         if (heldSpells.length > 0) {
-            lines.push(`{magenta-fg}✴ Sustained: ${heldSpells.join(', ')} (-${heldSpells.length * 2} dice){/magenta-fg}`);
+            const these = ledger.filter(w => w.kind === 'spell' && !(w.key === 'armor' && w.bearer === undefined));
+            lines.push(`{magenta-fg}✴ Sustained: ${heldSpells.join(', ')} (${sustainTotal(these)}){/magenta-fg}`);
         }
         // ACTIVE THREADS, WITHOUT ASKING (TNf9WrZGxCmCzqA4L: "instead of
         // saying 'sustain' to see the active threads, list the threads in
@@ -5348,7 +5369,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             : [];
         if (ownThreads.length > 0 || spriteHeld.length > 0) {
             const mine = ownThreads.length > 0
-                ? `${ownThreads.map(f => f.key).join(', ')} (-${ownThreads.length * 2} dice)`
+                ? `${ownThreads.map(f => f.key).join(', ')} (${sustainTotal(ledger.filter(w => w.kind === 'form'))})`
                 : `none yourself`;
             const carried = spriteHeld.length > 0 ? `  |  ${spriteHeld.join('; ')}` : '';
             lines.push(`{magenta-fg}✴ Threads: ${mine}${carried}{/magenta-fg}`);

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

@@ -824,8 +824,8 @@ Available in-game commands (use with [COMMAND] prefix):
   "manabolt" (combat damage resisted by body, not armor), "heal [on <ally>]" (heal
   physical wounds -- your own by default, or an ally's in your room; healing a
   wounded ally is a strong support move), "armor [on <ally>]" (sustained protection
-  on yourself or an ally; its bearer gets +soak at -2 dice to all else; cast at them
-  again to release). EVERY cast costs drain -- stun damage to YOU the caster; fill
+  on yourself or an ally; its bearer gets +soak, and YOU carry -2 dice to all else
+  while you hold it; cast at them again to release). EVERY cast costs drain -- stun damage to YOU the caster; fill
   your stun track and you're out cold. Never cast if you're mundane with no magic gear.
 - cast — bare "cast" attempts to magically bypass the ward/barrier in this room
   without knowing the answer (requires the same talent or gear; failing burns the

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

@@ -3630,6 +3630,8 @@ export class Player extends AbstractPlayer {
         if (next === this._sustainedArmor)
             return;
         this._sustainedArmor = next;
+        if (next === 0)
+            this.onSustainDropped('armor');
         // SUSTAINS BEAT ON FLIP (web report 2026-09-02: "I cast armor on myself
         // and don't see it in the sustained list"): the sheet only caught up on
         // the next unrelated beat. Every sustain mutator fires the hook now.
@@ -3658,29 +3660,130 @@ export class Player extends AbstractPlayer {
      * holding nothing.
      */
     sustainedNames() {
+        return this.sustainedWorkings().map(w => w.key);
+    }
+    /**
+     * EVERY WORKING THIS CHARACTER IS HOLDING UP, in one shape (2026-09-06).
+     *
+     * The sustaining rule (p.282: -2 dice per spell or complex form held)
+     * and its waivers (Focused Concentration p.74, Quickening p.326, a
+     * sprite's task p.256) were written against five named spell slots
+     * and a forms array, one branch each -- so a technomancer's Focused
+     * Concentration, which canon says covers a complex form exactly as it
+     * covers a spell, covered nothing, because forms were summed on a
+     * separate line. One list, composed at read time from the fields
+     * cast.ts and thread.ts already keep (the same way sustainedNames and
+     * sustainedMagnitudes read them), is what lets the rule be ONE rule.
+     *
+     * `force` is the Force a spell was cast at or the Level a form was
+     * threaded at -- the number a waiver's ceiling is measured against.
+     * A spell whose Force nobody recorded is `undefined`, and ineligible
+     * (honest, not generous). Barriers carry it in their seat; the other
+     * spells in `sustainedForces`.
+     */
+    sustainedWorkings() {
+        const mine = this.wornWorkings().filter(w => w.caster === undefined).map(({ caster: _c, ...w }) => w);
+        const onOthers = [];
+        for (const bearer of this.sustainedBearers) {
+            const held = bearer.wornWorkings().filter(w => w.caster === this);
+            if (held.length === 0) {
+                this.sustainedBearers.delete(bearer);
+                continue;
+            }
+            for (const { caster: _c, ...w } of held)
+                onOthers.push({ ...w, bearer: bearer.name });
+        }
+        return [...mine, ...onOthers];
+    }
+    /**
+     * Every working whose STATE is on this character, with who holds it
+     * up when that is somebody else. The bearer's view; sustainedWorkings
+     * is the holder's.
+     */
+    wornWorkings() {
+        const spell = (key, force) => ({
+            key, kind: 'spell', force, category: spellFor(key)?.category.toLowerCase(), caster: this.sustainedCasters.get(key),
+        });
         return [
-            ...this.sustainedForms.map(f => f.key),
-            ...(this._sustainedArmor > 0 ? ['armor'] : []),
-            ...(this.sustainedInvisibility ? ['invisibility'] : []),
-            ...(this.sustainedReflexes ? ['reflexes'] : []),
-            ...(this.sustainedBarrier ? ['barrier'] : []),
-            ...(this.sustainedManaBarrier ? ['manabarrier'] : []),
+            ...this.sustainedForms.map((f) => ({ key: f.key, kind: 'form', force: f.level })),
+            ...(this._sustainedArmor > 0 ? [spell('armor', this.sustainedForces.get('armor'))] : []),
+            ...(this.sustainedInvisibility ? [spell('invisibility', this.sustainedForces.get('invisibility'))] : []),
+            ...(this.sustainedReflexes ? [spell('reflexes', this.sustainedForces.get('reflexes'))] : []),
+            ...(this.sustainedBarrier ? [spell('barrier', this.sustainedBarrier.force)] : []),
+            ...(this.sustainedManaBarrier ? [spell('manabarrier', this.sustainedManaBarrier.force)] : []),
         ];
     }
+    /**
+     * The workings with what each one COSTS, and who is paying it off.
+     *
+     * A `sustain` effect (utilities/effects.ts) from any lane -- a quality
+     * held, a metamagic learned, one day a focus carried -- holds one
+     * working free. Waivers are matched most-specific first (an anchored
+     * slug, then a narrowed one, then a general one, lowest ceiling
+     * first), and each takes the highest-Force working it can cover: the
+     * general waiver must not spend itself on the spell the specific one
+     * was for. Every working costs the same two dice, so the assignment
+     * that leaves the fewest unwaived is the one that pays least.
+     */
+    sustainedLedger() {
+        const workings = this.sustainedWorkings();
+        const waivers = this.applyingEffects()
+            .flatMap(a => a.effect.type === 'sustain' ? [{ effect: a.effect, rating: a.rating, lane: a.lane, slug: a.slug }] : [])
+            .map(w => ({ ...w, ceiling: w.effect.property === 'anchored' ? Infinity : w.effect.value * scaleOf(w.effect, w.rating) }))
+            .sort((a, b) => {
+            const rank = (w) => w.effect.property === 'anchored' ? 0 : w.effect.only !== undefined ? 1 : 2;
+            return rank(a) - rank(b) || a.ceiling - b.ceiling;
+        });
+        const waivedBy = new Map();
+        for (const w of waivers) {
+            const covers = (x) => {
+                if (w.effect.property === 'anchored')
+                    return w.effect.only !== undefined && w.effect.only === x.key;
+                if (x.force === undefined)
+                    return false;
+                if (w.effect.only !== undefined && w.effect.only !== x.key && w.effect.only !== x.category)
+                    return false;
+                return x.force <= w.ceiling;
+            };
+            let pick = -1;
+            workings.forEach((x, i) => {
+                if (waivedBy.has(i) || !covers(x))
+                    return;
+                if (pick < 0 || (x.force ?? 0) > (workings[pick].force ?? 0))
+                    pick = i;
+            });
+            if (pick >= 0)
+                waivedBy.set(pick, this.effectSourceName(w.lane, w.slug));
+        }
+        return workings.map((x, i) => ({ ...x, cost: waivedBy.has(i) ? 0 : 2, waivedBy: waivedBy.get(i) }));
+    }
+    /** The row an applying effect came from, in the player's words. */
+    effectSourceName(lane, slug) {
+        switch (lane) {
+            case 'quality': return getQuality(slug)?.name ?? slug;
+            case 'initiate': return metamagicFor(slug)?.name ?? slug;
+            case 'adept': return adeptPowerFor(slug)?.name ?? slug;
+            case 'chrome': return augFor(slug)?.name ?? slug;
+            default: return slug;
+        }
+    }
     releaseSustainedWorkings() {
-        const count = this.sustainedForms.length
-            + (this._sustainedArmor > 0 ? 1 : 0)
-            + (this.sustainedInvisibility ? 1 : 0)
-            + (this.sustainedReflexes ? 1 : 0)
-            + (this.sustainedBarrier ? 1 : 0)
-            + (this.sustainedManaBarrier ? 1 : 0);
-        this.sustainedForms = [];
-        this._sustainedArmor = 0;
-        this.sustainedInvisibility = false;
-        this.sustainedReflexes = false;
-        this.sustainedBarrier = undefined;
-        this.sustainedManaBarrier = undefined;
-        return count;
+        // What this character HOLDS -- their own, and what they hold on
+        // others (which ends on the bearer). A spell somebody else holds on
+        // this character is that caster's concentration, and sleeping in
+        // it does not break it.
+        const held = this.sustainedWorkings();
+        for (const w of held) {
+            if (w.bearer === undefined) {
+                this.dropSustainedWorking(w.key);
+                continue;
+            }
+            for (const bearer of this.sustainedBearers) {
+                if (bearer.name === w.bearer)
+                    bearer.dropSustainedWorking(w.key);
+            }
+        }
+        return held.length;
     }
     // The other sustained spells (RAW gear/spell pass): invisibility bends
     // light around the bearer (+3 on sneak contests, npc.ts), increase
@@ -3692,6 +3795,8 @@ export class Player extends AbstractPlayer {
         if (this._sustainedInvisibility === v)
             return;
         this._sustainedInvisibility = v;
+        if (!v)
+            this.onSustainDropped('invisibility');
         this.noteConditionChanged();
     }
     _sustainedReflexes = false;
@@ -3700,8 +3805,73 @@ export class Player extends AbstractPlayer {
         if (this._sustainedReflexes === v)
             return;
         this._sustainedReflexes = v;
+        if (!v)
+            this.onSustainDropped('reflexes');
         this.noteConditionChanged();
     }
+    /**
+     * WHO HOLDS A SPELL THAT IS ON THIS CHARACTER, when it is not them
+     * (2026-09-06: "bill the caster, not the bearer"). SR5 p.282 puts the
+     * -2 on whoever SUSTAINS the spell; the subject only wears it. Until
+     * this the engine taxed the bearer -- a mundane street sam with an
+     * ally's armor on them lost two dice off every pool, and the mage
+     * holding it up paid nothing.
+     *
+     * The effect state stays on the bearer (that is what grants the
+     * soak); this map is the other half, and the caster's ledger reads
+     * it through `sustainedBearers`. Session-only, like every sustain.
+     */
+    sustainedCasters = new Map();
+    /** The characters this one holds a spell on. Pruned at read time. */
+    sustainedBearers = new Set();
+    /** Record that `caster` is the one holding `key` up on this character. */
+    sustainedBy(key, caster) {
+        if (caster === this) {
+            this.sustainedCasters.delete(key);
+            return;
+        }
+        this.sustainedCasters.set(key, caster);
+        caster.sustainedBearers.add(this);
+        caster.noteConditionChanged();
+    }
+    /** The caster holding `key` on this character, when it is somebody else. */
+    wornSpellCaster(key) {
+        return this.sustainedCasters.get(key);
+    }
+    /** Bookkeeping when a spell on this character ends, whoever ended it. */
+    onSustainDropped(key) {
+        this.sustainedForces.delete(key);
+        const caster = this.sustainedCasters.get(key);
+        if (caster) {
+            this.sustainedCasters.delete(key);
+            caster.noteConditionChanged();
+        }
+    }
+    /** End one working by key, whatever kind it is. */
+    dropSustainedWorking(key) {
+        switch (key) {
+            case 'armor':
+                this.setSustainedArmor(0);
+                return;
+            case 'invisibility':
+                this.sustainedInvisibility = false;
+                return;
+            case 'reflexes':
+                this.sustainedReflexes = false;
+                return;
+            case 'barrier':
+                this.sustainedBarrier = undefined;
+                return;
+            case 'manabarrier':
+                this.sustainedManaBarrier = undefined;
+                return;
+            default: {
+                const i = this.sustainedForms.findIndex(f => f.key === key);
+                if (i >= 0)
+                    this.sustainedForms.splice(i, 1);
+            }
+        }
+    }
     /** The sustained PHYSICAL BARRIER spell (ruling 2026-08-24): seals
      *  one exit of one room while held -- go.ts and move refuse passage
      *  for everyone (the caster included; walls don't play favorites).
@@ -3712,6 +3882,8 @@ export class Player extends AbstractPlayer {
         if (this._sustainedBarrier === v)
             return;
         this._sustainedBarrier = v;
+        if (!v)
+            this.onSustainDropped('barrier');
         this.noteConditionChanged();
     }
     /** The MANA BARRIER twin (canon p.294, RAG-checked): blocks SPIRITS
@@ -3723,6 +3895,8 @@ export class Player extends AbstractPlayer {
         if (this._sustainedManaBarrier === v)
             return;
         this._sustainedManaBarrier = v;
+        if (!v)
+            this.onSustainDropped('manabarrier');
         this.noteConditionChanged();
     }
     // THREADED COMPLEX FORMS (M4.15, see commands/thread.ts): the
@@ -3764,7 +3938,12 @@ export class Player extends AbstractPlayer {
     get formDefenseBonus() {
         return this.sustainedForms.some(f => f.key === 'static-veil') ? 2 : 0;
     }
-    /** The Force each sustained spell was cast at (cast.ts records it) -- Focused Concentration reads it. */
+    /**
+     * The Force each sustained spell was cast at, by spell slug (cast.ts
+     * records it; sustainedWorkings reads it). Cleared by the setter that
+     * drops the spell, so a recast at a new Force is judged fresh rather
+     * than against the number the last cast left behind.
+     */
     sustainedForces = new Map();
     noteSustainedForce(kind, force) {
         this.sustainedForces.set(kind, force);
@@ -3774,32 +3953,16 @@ export class Player extends AbstractPlayer {
         return this.isTechnomancer() ? 0 : this.qualityRating('gremlins');
     }
     get sustainingPenalty() {
-        // Each sustained effect costs -2 dice across the board: the armor
-        // spell, invisibility, hot reflexes, and open astral senses (see
-        // commands/assense.ts). They stack -- holding two is walking around
-        // half-blind. Dumpshock disorientation (p.229) rides the same rail.
-        // QUICKENING (metamagic, p.326 adapted): the armor spell anchors into
-        // the world and sustains itself -- its -2 simply never bills.
-        const armorCost = this._sustainedArmor > 0 && !this.hasMetamagic('quickening') ? 2 : 0;
-        // FOCUSED CONCENTRATION (p.74, RAG-checked 2026-09-02): "sustain one
-        // spell with a Force equal to or less than your rating without
-        // penalty". One spell, whose Force the cast recorded; a spell with
-        // no recorded Force is not eligible (honest, not generous).
-        const spells = [
-            { cost: armorCost, force: this.sustainedForces.get('armor') },
-            { cost: this.sustainedInvisibility ? 2 : 0, force: this.sustainedForces.get('invisibility') },
-            { cost: this.sustainedReflexes ? 2 : 0, force: this.sustainedForces.get('reflexes') },
-            { cost: this.sustainedBarrier ? 2 : 0, force: this.sustainedBarrier?.force },
-            { cost: this.sustainedManaBarrier ? 2 : 0, force: this.sustainedManaBarrier?.force },
-        ];
-        const focus = this.qualityRating('focused-concentration');
-        const waived = focus > 0 ? spells.find(sp => sp.cost > 0 && sp.force !== undefined && sp.force <= focus) : undefined;
-        if (waived)
-            waived.cost = 0;
-        return spells.reduce((n, sp) => n + sp.cost, 0)
+        // Each working held costs -2 dice across the board (p.282): a
+        // sustained spell, a threaded complex form. They stack -- holding
+        // two is walking around half-blind. Which ones are held FREE is the
+        // catalog's to say, through `sustain` effects (Focused Concentration
+        // p.74, Quickening p.326 adapted); the engine names no row here.
+        // Open astral senses (commands/assense.ts) and dumpshock
+        // disorientation (p.229) ride the same rail.
+        return this.sustainedLedger().reduce((n, w) => n + w.cost, 0)
             + (this.astralPerceiving ? 2 : 0)
-            + (this.dumpshocked ? 2 : 0)
-            + this.sustainedForms.length * 2;
+            + (this.dumpshocked ? 2 : 0);
     }
     // Astral perception (see commands/assense.ts): senses held OPEN as a
     // sustained state -- passive aura reads, at -2 dice to everything else.

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

@@ -105,7 +105,18 @@ export function parseCatalogVersion(raw) {
     const n = Number(raw);
     return Number.isFinite(n) ? n : undefined;
 }
+/**
+ * Set by resetCatalogForTest and never cleared: a suite that has reset
+ * the catalog wants ONLY what it applies. Found 2026-09-06, the day the
+ * developer's cache moved to v17 -- every fixture pinned at 16 lost the
+ * "highest version wins" contest to a file in the home directory, and
+ * eleven accessor tests went red on one machine and green on every
+ * other. Exactly the failure the note above says a test must not have.
+ */
+let diskCacheDisabled = false;
 function readCache() {
+    if (diskCacheDisabled)
+        return undefined;
     try {
         const parsed = JSON.parse(fs.readFileSync(cachePath(), 'utf8'));
         if (Array.isArray(parsed?.items) && parsed.items.length > 0)
@@ -571,6 +582,10 @@ export function resetCatalogForTest() {
     liveSource = undefined;
     resolved = undefined;
     fetchAttempted = false;
+    // The machine's cache is out of the contest from here on: a fixture
+    // applied after this is the whole catalog, whatever version it says.
+    // A test that wants a cache passes its own reader (CacheReader).
+    diskCacheDisabled = true;
     resetCatalogIndexes();
 }
 /**
@@ -697,6 +712,11 @@ export function describeEffect(e) {
         case 'cap': return e.property === 'chosen'
             ? `${sign}${e.value} to the maximum of one chosen ${e.category === 'skills' ? 'skill' : 'attribute'}${only}`
             : `${sign}${e.value} to the ${word} maximum${only}`;
+        // A waiver reads as what it holds FREE, not as dice: one entry, one
+        // working, and the ceiling it is measured against.
+        case 'sustain': return e.property === 'anchored'
+            ? `${e.only ? e.only.replace(/-/g, ' ') : 'a spell'} sustains itself -- no sustaining penalty`
+            : `sustain one ${e.only ? `${e.only.replace(/-/g, ' ')} ` : ''}spell or complex form up to Force ${e.value}${scale} with no penalty`;
     }
 }
 /** Fuzzy lookup for source.ts: exact slug, exact name, then loose

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

@@ -0,0 +1,36 @@
+/**
+ * THE SUSTAINING COST, IN THE PLAYER'S WORDS -- read from the engine's
+ * ledger, never restated (2026-09-06).
+ *
+ * Every line that reported a sustained working used to print a literal
+ * "-2 dice": the HUD, the cast echo, the spellbook, the sheet, the
+ * thread list. Player.sustainingPenalty was already waiving the spell a
+ * Focused Concentration holder was owed, and every one of those lines
+ * went on telling them they were paying for it. A number the engine
+ * computes is printed from the engine, or it is a lie waiting for the
+ * next rule.
+ */
+/** "-2 dice to everything else" or "no penalty -- Focused Concentration". */
+export function sustainBurden(entry, tail = '') {
+    if (!entry)
+        return `no penalty`;
+    if (entry.cost > 0)
+        return `-${entry.cost} dice${tail}`;
+    return entry.waivedBy ? `no penalty -- ${entry.waivedBy}` : `no penalty`;
+}
+/**
+ * The total for a group of workings: "-4 dice", or "no penalty" when
+ * every one is held free, or "-2 dice, invisibility free (Focused
+ * Concentration)" when only some are.
+ */
+export function sustainTotal(entries, tail = '') {
+    const total = entries.reduce((n, e) => n + e.cost, 0);
+    const free = entries.filter(e => e.cost === 0);
+    if (total === 0) {
+        const by = [...new Set(free.map(e => e.waivedBy).filter((n) => !!n))];
+        return by.length > 0 ? `no penalty -- ${by.join(', ')}` : `no penalty`;
+    }
+    const notes = free.map(e => `${e.key} free${e.waivedBy ? ` (${e.waivedBy})` : ''}`);
+    return `-${total} dice${tail}${notes.length > 0 ? `, ${notes.join(', ')}` : ''}`;
+}
+//# sourceMappingURL=sustaining.js.map

package/package.json

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