@maka/maka-cli 5.378.0 → 5.379.1

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

@@ -6,7 +6,7 @@ import { isOutdoorsPlace } from '../utilities/outdoors.js';
 import { exitContradictions } from '../utilities/district-plane.js';
 import { clampDeviceKind } from '../utilities/affordances.js';
 import { kitSlugForTier } from '../npc-kits.js';
-import { SIZE_SECURITY_BANDS, SIZE_HOST_BANDS, scopeFor, postsLieutenant, sizeForTier, highestOpposingPool, payFor, rollTwist, requirementsFor, DATA_RUN_SHARE, objectiveRoomFor, } from './job-order.js';
+import { SIZE_SECURITY_BANDS, SIZE_HOST_BANDS, scopeFor, postsLieutenant, sizeForTier, highestOpposingPool, payFor, rollTwist, requirementsFor, DATA_RUN_SHARE, objectiveRoomFor, isDataCourier, courierMustBeUnseen, } from './job-order.js';
 export { DATA_RUN_SHARE } from './job-order.js';
 /**
  * CHUNKED scene generation (see SceneSeedGenerator.generate for the
@@ -221,7 +221,10 @@ export function settleSecurity(skeleton, campaignTier, _player, crew, order) {
     // which rolls Host Rating x 2 (p.247-248); a physical job's is the
     // tier's statblock, lieutenant included when posted.
     const winItem = skeleton.items.find(i => i.name === skeleton.winCondition?.item);
-    const vault = winItem?.plane === 'matrix' ? skeleton.rooms.find(r => r.name === winItem.room) : undefined;
+    // A data courier's opposition is the DROP host's IC (its target), not
+    // the client the cargo starts with.
+    const vaultName = winItem?.plane === 'matrix' ? (skeleton.winCondition?.target ?? winItem.room) : undefined;
+    const vault = vaultName ? skeleton.rooms.find(r => r.name === vaultName) : undefined;
     const pool = vault ? 2 * (vault.hostRating ?? VAULT_HOST_RATING) : highestOpposingPool(settled, lieutenant);
     const heads = partyHeadcount(crew);
     const wrote = skeleton.winCondition?.payout;
@@ -280,7 +283,27 @@ export function buildSkeletonPrompt(tier, player, previousError, rumor, crew, ca
     // winCondition must therefore look like -- validateSkeleton holds the
     // model to exactly that.
     const kind = order?.kind ?? 'datasteal';
-    const kindBlock = kind === 'delivery' ? `
+    // THE DATA COURIER (user ruling 2026-10-04): a delivery whose package is
+    // a file and whose drop is a host (win-condition 'upload').
+    const courier = isDataCourier(kind, shape);
+    const unseen = courierMustBeUnseen(size);
+    const kindBlock = courier ? `
+THIS JOB IS A DATA COURIER RUN (SR5 p.338, delivery -- the package is DATA and the drop is a
+HOST). Build it accordingly:
+- The winCondition item is the CARGO FILE: role "winCondition", "plane": "matrix", category
+  Document, "heldBy" the CLIENT -- they push it onto the runner's device at the meet (the engine
+  does that the moment the meet is held). Never place it in a room, never in anyone else's hands.
+- winCondition.target is the DROP: a rooms[].name with "hasNode": true and a "hostRating" of
+  ${hostBand.min === hostBand.max ? hostBand.min : `${hostBand.min}-${hostBand.max}`} (this is a ${size} job), and NOT the client's room. The runner must get a persona
+  INSIDE that host and upload the file there. The host defends itself with its own ice at its
+  rating -- write NO "matrix"-plane npc. There is no "toNpc": nobody is handed anything.
+- WHY IT GOES THERE is the fiction: a plant (forged records, a worm, a confession, a backdoor,
+  evidence), a dead drop for someone who will come for it, a restore of something stolen.
+${unseen ? `- THIS IS A HARDER JOB: the plant must land UNSEEN -- the engine fails it if the host is on
+  alert when the file arrives. The site should make quiet hard: cameras, a spider who works
+  the host, staff who notice a runner where none should be.
+` : ''}- The client briefs the drop by its room name and says what the file is for.
+` : kind === 'delivery' ? `
 THIS JOB IS A DELIVERY (SR5 p.338: "take the thing to the place"). Build it accordingly:
 - The winCondition item is the CARGO: role "winCondition", "heldBy" the CLIENT -- they hand
   it over at the meet (the engine does that the moment the meet is held). Never place it in
@@ -340,7 +363,18 @@ ONE OBJECT.
 - There is NO winCondition item: omit "item" and "toNpc", and write NO items[] entry with
   role "winCondition".
 ` : '';
-    const winConditionSchema = kind === 'extraction' ? `
+    const winConditionSchema = courier ? `
+  "winCondition": {
+    "item": string, // the CARGO FILE: the items[].name with role "winCondition", "plane": "matrix",
+                     // heldBy the client (see THIS JOB IS A DATA COURIER RUN above)
+    "target": string, // the DROP: a rooms[].name with "hasNode": true -- the host it is uploaded to.
+                       // No "toNpc".
+    "payout": number, // the job's pay in nuyen. THE ENGINE SETS THE REAL FIGURE from the
+                       // site's securityTier (SR5 p.371: 3,000 per runner x the opposition's
+                       // dice pool / 4, plus the danger modifiers); write ${payFor({ pool: highestOpposingPool(band.min, postsLieutenant(size)), heads: partyHeadcount(crew), hostiles: 0, securityTier: band.min })}
+                       // here and it will be replaced. It is paid as one lump sum on the wrap.
+    "rewardItem"?: string // optional bonus: an items[].name with role "reward"
+  },` : kind === 'extraction' ? `
   "winCondition": {
     "target": string, // the PERSON: an npcs[].name, never the client -- see THIS JOB IS AN
                        // EXTRACTION above. No "item".
@@ -389,7 +423,7 @@ the runner's own fixer back home, who brokered this meet and is NOT in this scen
     // fixer" possible at all and why the objective below can be a `give`.
     // The two halves have to agree about WHERE the file is, so this block
     // says host-or-offline-server in the same vocabulary room.ts uses.
-    const dataRunBlock = shape !== 'data' ? '' : `
+    const dataRunBlock = shape !== 'data' || courier ? '' : `
 THIS JOB IS A DATA RUN -- a quiet one. The runner is being paid to STEAL A FILE, not to
 take ground. Build it accordingly:
 - The winCondition item is PAYDATA: a "matrix"-plane item, category Document, sitting
@@ -405,9 +439,9 @@ take ground. Build it accordingly:
   is a smash-and-grab wearing the wrong name. A site can still be WATCHED (cameras) --
   surveillance is pressure without being a gun.
 - Keep it SHORT and tight. One site, one host, one file.
-- The delivery still matters: the file comes out of the vault written to a chip, and the
-  chip is a physical object the runner carries and hands over. A "give" objective is the
-  natural shape.
+- The delivery still matters: the file is copied out of the vault onto the runner's device,
+  and handed over from there (or burned to a chip first). A "give" objective is the natural
+  shape.
 `;
     // THE TWIST (SR5 p.478), epic only: rolled fresh per attempt, and
     // written onto the skeleton by settleSecurity from the same order so
@@ -711,13 +745,17 @@ Hard structural rules (validated mechanically -- a violation is rejected):
         ? 'winCondition.target names a real npcs[].name that is NOT "client" and NOT winCondition.toNpc; winCondition.toNpc names a real npcs[].name in a different room; "willing" is a boolean; there is no items[] entry with role "winCondition".'
         : kind === 'assassination' || kind === 'destruction'
             ? `winCondition.target names a real ${kind === 'assassination' ? 'npcs[].name that is NOT "client"' : 'devices[].name that holds no door and grants nothing'}; there is no items[] entry with role "winCondition".`
-            : kind === 'delivery'
-                ? 'The winCondition item is heldBy "client"; winCondition.toNpc is NOT the client and does not stand in the client\'s room.'
-                : 'The winCondition item must not be heldBy winCondition.toNpc.'} If a matrix-plane item is the
+            : courier
+                ? 'The winCondition item is a "matrix"-plane file heldBy "client"; winCondition.target is a hasNode room that is NOT the client\'s room; there is no toNpc.'
+                : kind === 'delivery'
+                    ? 'The winCondition item is heldBy "client"; winCondition.toNpc is NOT the client and does not stand in the client\'s room.'
+                    : 'The winCondition item must not be heldBy winCondition.toNpc.'} If a matrix-plane item is the
   winCondition item, its room has hasNode true AND a "hostRating" of at least 4 -- the host
-  defends its own files with its own ice; never write an NPC for that. ${shape === 'data'
-        ? 'On THIS job (a data run) the winCondition item MUST be that matrix-plane item -- paydata lives on a host, never on a desk.'
-        : 'A Datachip/Document winCondition item may be either: a file on a host (then the rule above applies) or a physical chip in the meat world.'}
+  defends its own files with its own ice; never write an NPC for that. ${courier
+        ? 'On THIS job the cargo is that file -- it starts in the client\'s hands, and the HOST it goes to is the drop.'
+        : shape === 'data'
+            ? 'On THIS job (a data run) the winCondition item MUST be that matrix-plane item -- paydata lives on a host, never on a desk.'
+            : 'A Datachip/Document winCondition item may be either: a file on a host (then the rule above applies) or a physical chip in the meat world.'}
 - ${isContinuation
         ? 'ZERO "starting"-role items -- the runner arrives with everything they own. 4-6'
         : '3-5 "starting"-role items (basics the runner doesn\'t already own -- see the dossier), 4-6'}
@@ -842,6 +880,9 @@ function objectiveBrief(skeleton) {
     if (skeleton.jobKind === 'extraction' && wc?.target) {
         return `the objective (the PERSON: "${wc.target}" -- who they are, where they are held, ${wc.willing ? 'that they want out' : 'that they will not come quietly'}, and that they are to be brought to "${wc.toNpc}" alive)`;
     }
+    if (skeleton.jobKind === 'delivery' && wc?.item && wc.target) {
+        return `the objective (the CARGO FILE "${wc.item}", which they push onto the runner's device at the meet, and the DROP: the host of "${wc.target}", where it is to be uploaded -- and what the file is for)`;
+    }
     if (skeleton.jobKind === 'delivery' && wc?.item) {
         return `the objective (the CARGO "${wc.item}", which they hand over at the meet, and the DROP: "${wc.toNpc}" and where to find them)`;
     }
@@ -877,11 +918,17 @@ function paydataBriefingRule(skeleton) {
     const win = skeleton.items.find(i => i.name === skeleton.winCondition.item);
     if (win?.plane !== 'matrix')
         return '';
+    if (skeleton.winCondition.target) {
+        return `
+  THE CARGO "${win.name}" IS A FILE -- the client pushes it onto the runner's commlink or deck at
+  the meet, over the table's PAN. Never describe handing over a physical chip, drive or case.
+  The drop is the HOST of "${skeleton.winCondition.target}": the runner gets inside and uploads it.`;
+    }
     const host = win.room ? ` the host of "${win.room}"` : ' a host';
     return `
   THE OBJECTIVE "${win.name}" IS PAYDATA -- a FILE held on${host}, not an object in a room.
   The client briefs it as data: a file to be found inside that host and copied out over the
-  Matrix (onto a chip once it is downloaded, if you like). Never describe it as a physical
+  Matrix onto the runner's own device. Never describe it as a physical
   chip, drive or disk sitting in a room, on a shelf, or in a safe -- nothing in the meat
   world holds it until the runner downloads it.`;
 }
@@ -1328,6 +1375,12 @@ export function validateSkeleton(skeleton, _player, _crew, order) {
         if (prizes.length > 0)
             fail(`${word} has no prize item, but ${prizes.map(i => `"${i.name}"`).join(', ')} carries role "winCondition" -- make it loot or drop it.`);
     }
+    else if (isDataCourier(jobKind, order?.runType)) {
+        if (!skeleton.winCondition.item || !skeleton.winCondition.target)
+            fail('winCondition needs "item" (the cargo file) and "target" (the drop: a hasNode room) -- this job is a data courier run.');
+        if (skeleton.winCondition.toNpc)
+            fail('winCondition on a data courier run carries no "toNpc" -- the drop is a host, named by "target". Drop "toNpc".');
+    }
     else if (!skeleton.winCondition.item || !skeleton.winCondition.toNpc) {
         fail('winCondition needs "item" and "toNpc".');
     }
@@ -1541,7 +1594,25 @@ export function validateSkeleton(skeleton, _player, _crew, order) {
         if (!deviceNames.has(target))
             fail(`winCondition.target "${target}" is not in devices -- the object to wreck has to be a device in this scene.`);
     }
-    if (jobKind === 'delivery') {
+    if (isDataCourier(jobKind, order?.runType)) {
+        const cargo = skeleton.items.find(i => i.name === skeleton.winCondition.item);
+        if (cargo && cargo.heldBy !== skeleton.client)
+            fail(`the cargo file "${cargo.name}" must be heldBy the client "${skeleton.client}" -- they push it onto the runner's device at the meet. It is ${cargo.heldBy ? `heldBy "${cargo.heldBy}"` : cargo.room ? `in "${cargo.room}"` : 'unplaced'}.`);
+        if (cargo && cargo.plane !== 'matrix')
+            fail(`the cargo "${cargo.name}" is on the meat plane, and this job is a data courier run -- give it "plane": "matrix", category Document.`);
+        const dropName = skeleton.winCondition.target;
+        const drop = skeleton.rooms.find(r => r.name === dropName);
+        const meet = skeleton.npcs.find(n => n.name === skeleton.client);
+        if (!drop)
+            fail(`winCondition.target "${dropName}" is not one of the rooms -- the drop has to be a room whose host takes the upload.`);
+        else if (!drop.hasNode)
+            fail(`winCondition.target "${dropName}" has no "hasNode": true -- the drop is a HOST. Mark that room hasNode.`);
+        else if ((drop.hostRating ?? 0) < VAULT_HOST_RATING)
+            fail(`the drop host "${dropName}" has hostRating ${drop.hostRating ?? 'unset'} -- it defends itself with its own ice, so give it a hostRating of ${VAULT_HOST_RATING} or more.`);
+        if (drop && meet && meet.startLocation === drop.name)
+            fail(`the drop "${dropName}" is the client's own room -- the transit is the job. Put the drop host somewhere the runner has to get into.`);
+    }
+    else if (jobKind === 'delivery') {
         const cargo = skeleton.items.find(i => i.name === skeleton.winCondition.item);
         if (cargo && cargo.heldBy !== skeleton.client)
             fail(`the cargo "${cargo.name}" must be heldBy the client "${skeleton.client}" -- they hand it over at the meet. It is ${cargo.heldBy ? `heldBy "${cargo.heldBy}"` : cargo.room ? `in "${cargo.room}"` : 'unplaced'}.`);
@@ -1567,7 +1638,7 @@ export function validateSkeleton(skeleton, _player, _crew, order) {
     // cannot add a hasNode flag. Worded to route to 'skeleton' (no
     // "items[", no "Win condition item").
     const winItem = skeleton.items.find(i => i.name === skeleton.winCondition.item);
-    if (winItem && order?.runType === 'data' && winItem.plane !== 'matrix') {
+    if (winItem && order?.runType === 'data' && winItem.plane !== 'matrix' && !isDataCourier(jobKind, order?.runType)) {
         fail(`the winCondition item "${winItem.name}" is on the meat plane, and this job is a DATA RUN -- its prize is PAYDATA: give it "plane": "matrix", category Document, placed in a hasNode room (not heldBy anyone) with a hostRating of ${VAULT_HOST_RATING} or more. A chip lying on a desk is not a data run.`);
     }
     // The other half of the same rule, for ANY matrix-plane objective: the
@@ -1580,7 +1651,7 @@ export function validateSkeleton(skeleton, _player, _crew, order) {
     // which is how four programs ended up bargaining over a chip in Vex's
     // log. Canon has none of that: the host launches its own IC at its
     // rating (p.247), so what a vault needs is a rating worth the name.
-    if (winItem?.plane === 'matrix') {
+    if (winItem?.plane === 'matrix' && !isDataCourier(jobKind, order?.runType)) {
         if (!winItem.room) {
             fail(`the winCondition item "${winItem.name}" is matrix-plane paydata but has no "room" -- data lives on a host, never in a pocket. Place it in a hasNode room.`);
         }
@@ -1626,7 +1697,10 @@ export function validateSkeleton(skeleton, _player, _crew, order) {
             fail(`room "${room.name}" has "hasNode": true but no "hostPurpose" -- every host is FOR something (what this place runs on it, and so what it protects). Give it a hostPurpose phrase, or drop hasNode if the place would run nothing worth taking.`);
         }
         const holds = skeleton.items.some(i => i.plane === 'matrix' && i.room === room.name);
-        if (!holds) {
+        // A DATA COURIER'S DROP is empty until the runner fills it -- the file
+        // coming in is what it is for (normalizeSkeleton keeps it too).
+        const courierDrop = isDataCourier(jobKind, order?.runType) && skeleton.winCondition.target === room.name;
+        if (!holds && !courierDrop) {
             fail(`room "${room.name}" is a host (${room.hostPurpose}) with NOTHING inside it -- no "matrix"-plane item placed in that room. A host holds what its business protects: put at least one matrix-plane item there (the ledger, the client list, the camera archive), or drop hasNode.`);
         }
         // "Ice stationed on it" used to be the third requirement. It is
@@ -2037,6 +2111,10 @@ export function normalizeSkeleton(skeleton) {
         const holds = (skeleton.items ?? []).some(i => i.plane === 'matrix' && i.room === room.name);
         if (holds)
             continue;
+        // A DATA COURIER'S DROP is empty until the runner fills it (item +
+        // target: win-condition 'upload'). Its purpose is the file coming in.
+        if (skeleton.winCondition?.item && skeleton.winCondition?.target === room.name)
+            continue;
         delete room.hasNode;
         delete room.hostRating;
         delete room.hostPurpose;
@@ -2057,8 +2135,11 @@ export function normalizeSkeleton(skeleton) {
         }
     }
     const winItem = (skeleton.items ?? []).find(i => i.name === skeleton.winCondition?.item);
-    if (winItem?.plane === 'matrix' && winItem.room) {
-        const vault = (skeleton.rooms ?? []).find(r => r.name === winItem.room);
+    // The vault is where the paydata sits -- or, on a data courier run, the
+    // host the cargo is going to (its target).
+    const vaultRoom = winItem?.plane === 'matrix' ? (skeleton.winCondition?.target ?? winItem.room) : undefined;
+    if (vaultRoom) {
+        const vault = (skeleton.rooms ?? []).find(r => r.name === vaultRoom);
         if (vault?.hasNode && (vault.hostRating ?? 0) < VAULT_HOST_RATING) {
             const was = vault.hostRating === undefined ? 'no hostRating' : `hostRating ${vault.hostRating}`;
             vault.hostRating = VAULT_HOST_RATING;
@@ -3133,23 +3214,35 @@ export function assembleScene(skeleton, details, playerName) {
             lifestyleChoices: [{ type: 'residence', metadata: { tier: 'Street', location: startRoom } }],
             startingItems,
         },
-        winCondition: skeleton.winCondition.target
+        winCondition: skeleton.jobKind === 'delivery' && skeleton.winCondition.item && skeleton.winCondition.target
+            // THE DATA COURIER (win-condition 'upload'): a file to a host. The
+            // engine -- never the model -- decides whether it must land unseen.
             ? {
-                type: skeleton.jobKind === 'destruction' ? 'destroy' : skeleton.jobKind === 'extraction' ? 'extract' : 'kill',
+                type: 'upload',
+                item: skeleton.winCondition.item,
                 target: skeleton.winCondition.target,
-                ...(skeleton.jobKind === 'extraction' ? { toNpc: skeleton.winCondition.toNpc, willing: skeleton.winCondition.willing } : {}),
+                ...(courierMustBeUnseen(skeleton.jobSize) ? { undetected: true } : {}),
                 rewardItem: skeleton.winCondition.rewardItem,
                 payout: skeleton.winCondition.payout,
                 completionMessage: skeleton.completionMessage,
             }
-            : {
-                type: 'give',
-                item: skeleton.winCondition.item,
-                toNpc: skeleton.winCondition.toNpc,
-                rewardItem: skeleton.winCondition.rewardItem,
-                payout: skeleton.winCondition.payout,
-                completionMessage: skeleton.completionMessage,
-            },
+            : skeleton.winCondition.target
+                ? {
+                    type: skeleton.jobKind === 'destruction' ? 'destroy' : skeleton.jobKind === 'extraction' ? 'extract' : 'kill',
+                    target: skeleton.winCondition.target,
+                    ...(skeleton.jobKind === 'extraction' ? { toNpc: skeleton.winCondition.toNpc, willing: skeleton.winCondition.willing } : {}),
+                    rewardItem: skeleton.winCondition.rewardItem,
+                    payout: skeleton.winCondition.payout,
+                    completionMessage: skeleton.completionMessage,
+                }
+                : {
+                    type: 'give',
+                    item: skeleton.winCondition.item,
+                    toNpc: skeleton.winCondition.toNpc,
+                    rewardItem: skeleton.winCondition.rewardItem,
+                    payout: skeleton.winCondition.payout,
+                    completionMessage: skeleton.completionMessage,
+                },
         client: skeleton.client,
         ...(skeleton.jobSize ? { jobSize: skeleton.jobSize } : {}),
         ...(skeleton.jobKind ? { jobKind: skeleton.jobKind } : {}),

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

@@ -662,6 +662,15 @@ Key Locations: ${json.rooms.map(r => r.name).join(', ')}
                         throw new Error(`Win condition references NPC "${wc.toNpc}", which is not in "npcs".`);
                     }
                 }
+                // THE COURIER'S DROP IS A HOST (win-condition 'upload'): the
+                // target names a room, and that room must stand under one.
+                if (wc.type === 'upload') {
+                    const drop = wc.target ? scene.getRooms()[wc.target] ?? Object.values(scene.getRooms()).find(r => r.name === wc.target) : undefined;
+                    if (!drop)
+                        throw new Error(`Win condition type "upload" requires "target", a room -- "${wc.target}" is not in "rooms".`);
+                    if (!drop.host || drop.offlineServer)
+                        throw new Error(`Win condition type "upload" targets "${wc.target}", which has no host to upload to -- mark it hasNode.`);
+                }
             }
             let rewardItem;
             if (wc.rewardItem) {
@@ -676,6 +685,7 @@ Key Locations: ${json.rooms.map(r => r.name).join(', ')}
                 toNpc: wc.toNpc,
                 target: wc.target,
                 willing: wc.willing,
+                undetected: wc.undetected,
                 rewardItem,
                 completionMessage: wc.completionMessage,
                 payout: wc.payout

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

@@ -914,6 +914,11 @@ export class SceneSeedGenerator {
         const wc = candidate.winCondition;
         if (!wc || !wc.item)
             return;
+        // A COURIER'S CARGO (win-condition 'upload') is a file the client
+        // HOLDS -- it starts in their hands, not on a host; the drop host is
+        // validated at the skeleton (scene-chunks.ts validateSkeleton).
+        if (wc.type === 'upload')
+            return;
         const item = (candidate.items ?? []).find(i => i.name === wc.item);
         if (!item || item.plane !== 'matrix')
             return;

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

@@ -78,6 +78,9 @@ import { TakeCommand } from './commands/take.js';
 import { MessageCommand } from './commands/message.js';
 import { MessagesCommand } from './commands/messages.js';
 import { DownloadCommand } from './commands/download.js';
+import { UploadCommand } from './commands/upload.js';
+import { TransferCommand } from './commands/transfer.js';
+import { receiveData } from './utilities/data-library.js';
 import { LootCommand } from './commands/loot.js';
 import { NoteCommand } from './commands/note.js';
 import { BacklogCommand } from './commands/backlog.js';
@@ -4513,6 +4516,25 @@ export default class Game {
                     Logger.getInstance().write(`Delivery: ${client.name} handed "${wc.item}" to ${this.player.name} at the meet.`);
                 }
             }
+            // THE DATA COURIER'S CARGO (win-condition 'upload', user ruling
+            // 2026-10-04): the package is a file, so the Johnson does not slide
+            // anything across the table -- they push it onto the runner's
+            // device (data-library receiveData; a chip only for a runner who
+            // carries no device at all). The drop is a HOST, and the meet says
+            // which, on its own line for the same terse() reason as above.
+            if (wc?.type === 'upload' && wc.item && johnson && johnson.inventory.hasItem(wc.item)) {
+                const cargo = johnson.inventory.getItem(wc.item);
+                johnson.inventory.removeItem(cargo.name);
+                const { device } = receiveData(this.player, cargo);
+                this.scene.updateInventory(this.player.inventory);
+                lines.push(device
+                    ? `THE CARGO: ${client.name} pushes ${cargo.name} onto your ${device.name}.`
+                    : `THE CARGO: ${client.name} hands you ${cargo.name} on a chip -- you carry nothing with a library to push it to.`);
+                if (wc.target) {
+                    lines.push(`THE DROP: the host at ${wc.target}. Get inside it and "upload ${cargo.name}"${wc.undetected ? ` -- and get it in before anyone knows you're there. A plant they watch land is worth nothing` : ''}.`);
+                }
+                Logger.getInstance().write(`Data courier: ${client.name} pushed "${cargo.name}" to ${this.player.name}${device ? `'s ${device.name}` : ' (chip)'} at the meet.`);
+            }
         }
         // THE PERSON HANDED OVER TO THE CLIENT (win-condition 'extract'):
         // when the client is the delivery point, any face time with them
@@ -4979,6 +5001,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('message', MessageCommand);
         CommandFactory.registerCommand('messages', MessagesCommand);
         CommandFactory.registerCommand('download', DownloadCommand);
+        CommandFactory.registerCommand('upload', UploadCommand);
+        CommandFactory.registerCommand('transfer', TransferCommand);
         CommandFactory.registerCommand('loot', LootCommand);
         CommandFactory.registerCommand('note', NoteCommand);
         CommandFactory.registerCommand('backlog', BacklogCommand);

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

@@ -221,6 +221,32 @@ export class Host {
             return [];
         return this.over.inventory.getAllItems().filter(i => i.plane === 'matrix');
     }
+    /**
+     * THE HOST'S DIGITAL INVENTORY (user ruling 2026-10-04), the write half
+     * of files(). Every write to a host's archive goes through these two --
+     * an upload lands here, an erase leaves from here -- so the storage
+     * underneath (the matrix-plane entries of the room it stands over, which
+     * the hub overlay already persists) is one place to change, not ten.
+     */
+    addFile(file) {
+        file.plane = 'matrix';
+        file.atSpot = undefined;
+        this.over.inventory.addItem(file);
+    }
+    /** Takes a file out of the archive by name; true when one was there. */
+    removeFile(name) {
+        const lower = name.toLowerCase();
+        if (!this.files().some(f => f.name.toLowerCase() === lower))
+            return false;
+        this.over.inventory.removeItem(name);
+        this.over.plainSightItems.delete(lower);
+        return true;
+    }
+    /** True when the archive holds a file of that name. */
+    hasFile(name) {
+        const lower = name.toLowerCase();
+        return this.files().some(f => f.name.toLowerCase() === lower);
+    }
     /** The locked doors of the room it stands over -- what a crack releases. */
     maglocks() {
         return Array.from(this.over.exits.values())

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

@@ -971,6 +971,18 @@ export class Item extends AbstractItem {
      * here; utilities/sin.ts reads them from here.
      */
     papers = [];
+    /**
+     * THE DEVICE'S DATA LIBRARY (digital inventory, user ruling 2026-10-04).
+     * A file copied off a host (Edit File, SR5 p.239: "you are the new
+     * file's owner") lives on the device that carried the persona -- "all
+     * of it fits on your commlink (or cyberdeck if you prefer)", p.222-223
+     * -- not as a chip in the pack. Each entry stays plane 'matrix'. A
+     * commlink, a deck or an RCC holds one (holdsData); a file moves
+     * between them, onto a host (upload) or onto a datachip ("transfer
+     * <file> to chip") -- utilities/data-library.ts. Canon gives storage no
+     * practical cap (p.222), so neither does this.
+     */
+    files = [];
     /** On a license: the name of the fake SIN it was bought for. */
     linkedSin;
     /** On a license: the TYPE it permits, by `license` row slug (v24,
@@ -990,6 +1002,10 @@ export class Item extends AbstractItem {
     holdsPapers() {
         return this.category === Category.Commlink || this.isCyberdeck() || this.isRcc();
     }
+    /** A device with a data library (files): the same three that hold papers. */
+    holdsData() {
+        return this.holdsPapers();
+    }
     /** A data-soft chip: Mapsoft, Shopsoft, Datasoft (utilities/programs.ts DATA_SOFTS). */
     get softKey() {
         return this.category === Category.Software ? findSoft(this.name)?.key : undefined;

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

@@ -1539,6 +1539,43 @@ export class Scene extends AbstractScene {
         this.logger.logWithColor(banner, 'green');
         return banner;
     }
+    /**
+     * THE COURIER'S PLANT (win-condition 'upload', user ruling 2026-10-04):
+     * met when the named file is written onto the named room's host by
+     * Edit File's create (commands/upload.ts). A delivery whose package is
+     * data (p.338): nothing changes hands in person, so this is a state
+     * check on the host, like erase -- but it is a CLIENT job and pays like
+     * one: completeObjective leaves the money with the Johnson until the
+     * runner reports in (Game.onClientInteraction).
+     *
+     * `undetected` (the harder jobs): a host on alert has its spider and
+     * its Patrol looking (host.ts `alert`, which canon never stands down),
+     * and a file that lands under those eyes is found. The upload still
+     * happens -- the runner made the edit -- but the plant is blown and the
+     * objective is not met; the line returned says so. Returns null when
+     * this is not the objective, it is already met, or the file or host do
+     * not match.
+     */
+    checkUploaded(itemName, roomName, byName, hostAlert) {
+        const condition = this._winCondition;
+        if (!condition || this._completed || condition.type !== 'upload')
+            return null;
+        if (!condition.item || condition.item.toLowerCase() !== itemName.toLowerCase())
+            return null;
+        if (!condition.target || condition.target.toLowerCase() !== roomName.toLowerCase())
+            return null;
+        if (condition.undetected && hostAlert) {
+            this.addWorldEvent(`${byName} planted ${itemName} on an alerted host -- the spider saw it land.`, { plane: 'matrix' });
+            this.logger.write(`Scene upload objective blown: "${itemName}" landed on ${roomName}'s host while it was on alert.`);
+            const blown = `The file lands -- and the host is awake. Its spider watches ${itemName} arrive in real time, and a plant somebody saw land is no plant at all. The job wanted it in clean.`;
+            this.logger.logWithColor(blown, 'yellow');
+            return blown;
+        }
+        const possessorPlayer = this.getPlayerByName(byName);
+        this.addWorldEvent(`${byName} planted ${itemName} on ${roomName}'s host -- the job is done.`, { plane: 'matrix' });
+        this.logger.write(`Scene upload objective met: "${byName}" uploaded "${itemName}" to ${roomName}'s host.`);
+        return this.completeObjective(condition, possessorPlayer);
+    }
     /**
      * THE ERASE OBJECTIVE (loose ends, 2026-09-14): met when the named file
      * is DELETED by Edit File (commands/edit-file.ts) -- a state change on

package/bundle/typescript/src/commands/game/sideQuest/utilities/data-library.js

@@ -0,0 +1,158 @@
+import { Category } from '../types/shared/item-enum.js';
+import { serializeItem, restoreItem } from './persistence.js';
+import { fuzzyPickName } from './fuzzy-match.js';
+/**
+ * Every device on this runner with a data library: the housed device, the
+ * worn commlink, then every commlink / deck / RCC in the pack. A device
+ * appears once however many readers would have named it.
+ */
+export function dataDevices(player) {
+    const out = [];
+    const add = (d) => {
+        if (d && d.holdsData() && !out.includes(d))
+            out.push(d);
+    };
+    add(player.housedDeck());
+    add(player.equipment?.head?.commlink ?? undefined);
+    for (const i of player.inventory.getAllItems())
+        add(i);
+    return out;
+}
+/**
+ * WHERE A DOWNLOAD LANDS: the device carrying the persona (p.239, the
+ * copier owns the copy -- on the hardware they are running), else the
+ * first data device on you. Undefined for a runner with none at all -- a
+ * technomancer's living persona has no storage to write to (p.250-251),
+ * and download.ts refuses the copy rather than inventing a chip.
+ */
+export function libraryDevice(player) {
+    const persona = player.personaDevice();
+    if (persona && persona.holdsData() && dataDevices(player).includes(persona))
+        return persona;
+    return dataDevices(player)[0];
+}
+/** Every file on every device, device by device. */
+export function deviceFiles(player) {
+    return dataDevices(player).flatMap(device => device.files.map(file => ({ file, device })));
+}
+/** Data chips in the pack: a file written to physical media. */
+export function dataChips(player) {
+    return player.inventory.getAllItems().filter(i => i.category === Category.Datachip);
+}
+/**
+ * A file this runner holds BY EXACT NAME, wherever it sits: a device
+ * library first, then the pack (a chip, or any carried item -- the
+ * historical shape a delivery looked for). The objective readers ask this.
+ */
+export function heldByName(player, name) {
+    const lower = name.toLowerCase();
+    const onDevice = deviceFiles(player).find(h => h.file.name.toLowerCase() === lower);
+    if (onDevice)
+        return onDevice;
+    const carried = player.inventory.getItem(name);
+    return carried ? { file: carried } : undefined;
+}
+/** A device file by a player's fuzzy query. */
+export function findDeviceFile(player, query) {
+    const all = deviceFiles(player);
+    const picked = fuzzyPickName(query, all.map(h => h.file.name));
+    return picked ? all.find(h => h.file.name === picked) : undefined;
+}
+/** A device on this runner by a player's fuzzy query ("deck", "commlink", the full name). */
+export function findDataDevice(player, query) {
+    const devices = dataDevices(player);
+    const q = query.toLowerCase().trim();
+    if (!q)
+        return undefined;
+    const exact = devices.find(d => d.name.toLowerCase() === q);
+    if (exact)
+        return exact;
+    const byKind = devices.find(d => (q === 'deck' || q === 'cyberdeck') ? d.isCyberdeck()
+        : q === 'rcc' ? d.isRcc()
+            : (q === 'commlink' || q === 'comm' || q === 'link') ? d.category === Category.Commlink : false);
+    if (byKind)
+        return byKind;
+    const picked = fuzzyPickName(query, devices.map(d => d.name));
+    return picked ? devices.find(d => d.name === picked) : undefined;
+}
+/** True when the device already holds a file of that name. */
+export function deviceHas(device, name) {
+    const lower = name.toLowerCase();
+    return device.files.some(f => f.name.toLowerCase() === lower);
+}
+/**
+ * A FRESH COPY of a file (Edit File's copy, p.239): same name, same
+ * content, owned by whoever made it. The original is untouched.
+ */
+export function copyFile(file, owner) {
+    const copy = restoreItem(serializeItem(file));
+    copy.plane = 'matrix';
+    copy.atSpot = undefined;
+    if (owner !== undefined)
+        copy.owner = owner;
+    return copy;
+}
+/** Writes a file into a device's library (plane 'matrix', no spot). */
+export function fileOnto(device, file) {
+    file.plane = 'matrix';
+    file.atSpot = undefined;
+    device.files.push(file);
+}
+/** Takes a file out of whatever shelf holds it; true when it moved. */
+export function releaseHeld(player, held) {
+    if (held.device) {
+        const at = held.device.files.indexOf(held.file);
+        if (at < 0)
+            return false;
+        held.device.files.splice(at, 1);
+        player.noteConditionChanged();
+        return true;
+    }
+    return player.removeInventory(held.file);
+}
+/**
+ * Burns a device file onto a datachip in the pack -- a MOVE, the file
+ * leaves the library (user ruling: physical media is one move, not two).
+ * Throws when the pack cannot take the weight, before anything moves.
+ */
+export function burnToChip(player, held) {
+    const chip = held.file;
+    if (player.currentWeight + chip.weight * chip.quantity > player.maxCarryingWeight) {
+        throw new Error('too heavy');
+    }
+    releaseHeld(player, held);
+    chip.plane = 'meat';
+    chip.category = Category.Datachip;
+    player.inventory.addItem(chip);
+    player.noteConditionChanged();
+    return chip;
+}
+/** Reads a chip from the pack onto a device -- a MOVE, the chip is consumed. */
+export function loadChip(player, chip, device) {
+    player.removeInventory(chip);
+    fileOnto(device, chip);
+    player.noteConditionChanged();
+}
+/**
+ * WHERE DATA HANDED TO A RUNNER LANDS: a device library when they carry
+ * one, else -- a runner with no commlink, no deck, no RCC -- the pack, as
+ * a chip. The second arm is not a loophole: something has to hold the
+ * cargo, and physical media is the only thing a deviceless runner owns.
+ */
+export function receiveData(player, file) {
+    const device = libraryDevice(player);
+    if (device) {
+        fileOnto(device, file);
+        player.noteConditionChanged();
+        return { device };
+    }
+    file.plane = 'meat';
+    file.category = Category.Datachip;
+    player.inventory.addItem(file);
+    return {};
+}
+/** Every file name this runner holds, devices and chips -- for the runner ops. */
+export function heldDataNames(player) {
+    return deviceFiles(player).map(h => h.file.name);
+}
+//# sourceMappingURL=data-library.js.map