EDGEhack design

Draft 1, agreed by the owner on 2026-11-04 (“Your design looks good, I think we can proceed”), with the recommendation in each open question taken as the answer. H1 is under way.

EDGEhack is the EDGE platform’s quickhack editor for Cyberpunk 2077: a VS Code extension (edgemodders.edgehack) with its own activity bar icon. Open any quickhack in the game and see and change everything about it: its name, icon, tier, RAM cost, upload time, cooldown, duration, damage, and the effects it applies. Make new quickhacks, and add buffs, debuffs and attack features to one, taken from other quickhacks or from any of the game’s status effects that can be applied to an enemy.

What the owner asked for (2026-11-04)

How the game builds a quickhack

Read on game 2.5 on 2026-11-04 through REDbridge (tweakdb.record, tweakdb.records, the game’s own tweakdb_ep1.bin), and from the game’s scripts for how the quickhack list is made (RPGManager.GetPlayerQuickHackListWithQuality, still in 2.5’s types). A quickhack is TweakDB records only: no archive file holds one. Its icons are the only part that lives in archives, as parts of .inkatlas files.

The chain of records

Overheat at tier 3 (Items.OverheatLvl2Program) as the example:

Every quickhack shares four effects (QuickHack.QuickHack_inline2, _inline6, _inline8, _inline9): armor down while hacked, refresh Ping, the target marked as quickhacked, and V’s short upload status. A change to a shared record changes every quickhack, so EDGEhack must copy a shared record before changing it (see Writing a mod).

Tiers, families and variants

The pools to pick from

Not every status effect works on an enemy: many are V’s own (cooldowns, cyberware buffs, PlayerCooldown), some belong to a boss fight (Chimera.*, AdamSmasher.*, Oda.*), some need an NPC state (AIData prerequisites such as NPCType.Human). The picker sorts them into Works on enemies, V’s own and Boss fights, from their tags, type, prefix and where the game already uses them (an effect some quickhack or grenade already puts on a target is the safest pick). The sorting rules are part of H3 and are checked in the game.

Writing a mod

A quickhack mod is plain files a modder can read:

EDGEhack’s own document. The modder’s work is a <name>.quickhack.json file in the project’s source/raw/edgehack/ (or on the Desk): what the quickhack starts from, what changed, the effects added, the texts and icons. EDGEhack writes the YAML, the onscreens file and the atlas from it, into REDcode’s project, on Add to Project and on every save after that. The written YAML carries a header saying it is made by EDGEhack. This is EDGEwave’s way (.edgewave document, rendered WAV) and EDGEquest’s. The reasons: the YAML for one quickhack spans many records with generated names; a document in the modder’s words survives a change of how EDGEhack writes it; and a modder can still open and read the YAML.

Changing a game quickhack writes TweakXL changes to its own records (Items.OverheatLvl2Program: { … }). Records it shares with other quickhacks (the four common effects, BaseOverheat_inline0 that every Overheat tier uses) are copied under the mod’s names first and the copy is changed, so nothing else changes by accident. A copy is a new record id, so the YAML stays small: only what differs.

A new quickhack is a copy of a family under the mod’s own ids (Items.EDGEhack_<Name>Program, QuickHack.EDGEhack_<Name>Hack, …) with TweakXL’s $base, then the changes. It also has to reach the enemy’s own list of hacks (H3: plan). And it needs a way into V’s hands: a crafting spec V knows from the start, a vendor’s stock, or a gift through REDnode’s console while testing. The editor’s Get it section picks one.

Names given to new records are fixed once written (saves and other mods refer to them); renaming the quickhack later changes only its texts.

The editor

A custom editor for .quickhack.json, opened from the Quickhacks view, the Desk, the Library, REDcode, or another tool. For a game quickhack with no document yet, it opens a read-only view of the game’s records, with Edit (makes the document on the Desk) and Clone and Modify.

Words are the modder’s, not TweakDB’s. The page:

Numbers show the game’s values next to the changed ones, and each tier’s value, so a modder can see the curve. A number that is a formula in the game (cost scaled by the target’s resistance) shows the base value and says what scales it.

Adding effects

Add Effect opens a picker with three sources:

An added effect is referenced when it is unchanged (the YAML adds the game’s record to the action’s effect list) and copied as soon as the modder changes its duration, stacks or damage. The effects list shows which is which.

Combining has rules the editor checks, each as a warning, not a block:

• Two effects of the same statusEffectType may replace each other on the target. Two different burns ran side by side in H3.1’s test, so Burning and Misc give no warning; other types are unverified.
• The same status effect twice on a tier, its own and an added one: one upload may count as two stacks, or as one. Unverified.
• A status effect with no duration may stay until something removes it. Unverified.
• Effects with PlayerCooldown, cyberware or boss-fight tags are V’s or a boss’s: shown only with Show all, with a warning if one goes on a target.
• The cooldown, the “was quickhacked” mark and the RAM cost always stay; they are not in the effects list.

The editor also shows notes, apart from the warnings. A warning means something may not work as the modder expects: the game may do something irregular, or nobody has seen it run. A note is the game working as designed, worth knowing when combining (the owner’s distinction, 2026-11-07). Notes are grey with an info mark; warnings are yellow.

• An effect whose AIData needs a kind of NPC (humans only): the rest do not act it out, but the effect itself runs on them (a drone took Contagion’s poison, Human only, and a bleed in H3.4’s test). No message: that machines do not act out a poison is self-evident to players (the owner, 2026-11-07).
• A burn and Contagion’s poison on one tier: Contagion Epic and better give V a passive in the cyberdeck (EquipmentGLP.ContagionLvl3Passive). A hit on a burning target removes every poison tagged ContagionPoison, and the game’s own Epic and better poisons (ContagionPoisonLvl3, Lvl4, Lvl4PlusPlus, checked by record name) explode too (Attacks.ContagionBurnCombo). So a copy with changed numbers is removed without the explosion. Found in H3.4’s test; without that Contagion in the deck, both ran for their whole time.
• Poison and bleed stay off machines (decided by the owner, 2026-11-07, after a drone took Triple Heat’s poison and bleed in H3.4’s test). The game keeps machines safe only per quickhack: Contagion cannot be uploaded to one, but its poison has no check of its own, so it reaches a machine through a hack that can (Overheat). In a quickhack EDGEhack builds, any poison or bleed (statusEffectType Poisoned or Bleeding) does no damage to androids, drones and mechs, and the editor shows a note saying EDGEhack does so: a deliberate change, more intuitive than the game’s. How it is written, from H3.4b’s spike (docs/testing.md): immunityStats is not checked when a quickhack applies an effect, but a prereqRecord on the damage effector is. So each poison and bleed gets its own copy of its damage effector with EDGEhack’s own stat check (StatPrereq, IsMechanical LessOrEqual 0 on the Owner, as Overheat’s OverheatLevel2_inline9). On a machine neither its damage nor its icon shows: seen on a drone and an android in H3.4b’s test.

Views

The activity bar container EDGEhack (icon: a quickhack shard in the HUD brackets) with three views:

“Quickhacks” rather than “Game Assets”: the view lists TweakDB records, not archive files, and “Game Assets” in REDcode and EDGEwave means archive files. Enemy netrunners’ hacks (AIQuickHack.*) are left out at first.

Desk and Library

Following the shared rules in EDGEbuilder’s docs/library.md (draft 3):

• Desk: %LOCALAPPDATA%\EDGEhack\desk\<name>.quickhack.asset\, already in the Library’s item shape, as EDGEfab’s Desk is, so Add to Library is a copy. Each folder has asset.json and source/raw/edgehack/<name>.quickhack.json; written YAML and atlas only appear once it goes into a project. A quickhack made with no project open lands on the Desk.
• Library: the shared root in %APPDATA%\EDGE\library.json, items <name>.quickhack.asset/ with asset.json (kind: "quickhack", main the .quickhack.json). The kind quickhack is new: EDGEbuilder owns the list of kinds, so EDGEhack asks there with a request issue (to agree with the owner first). Add to Project writes the came-from note source/library.json as the shared rules say.

Opening a quickhack from anywhere

Today there is no shared way: REDcode calls other tools’ commands it knows by name (edgewave.openSound, edgemat.openMesh), and other tools add menu entries to REDcode’s views by viewItem. REDcode’s TweakDB view marks every record the same way (tweakRecord), so a menu entry cannot show only on quickhacks.

Proposed, in two steps:

1. H1, with no change elsewhere: EDGEhack’s command edgehack.openQuickhack takes a record path or id, a REDcode tree node, a REDcode record page’s record, or a .quickhack.json URI, and finds the family from any record in the chain (the item, any tier’s action, a Boss or Spread action, the recipe). EDGEhack adds Open in EDGEhack to REDcode’s TweakDB view menu for every record, and the command says “not a quickhack” for the rest. Other EDGE tools can call the command.

2. A REDcode request, an open contract for every EDGE tool: each tool declares in its package.json what it opens, and REDcode reads it from vscode.extensions.all without starting the tool:

   "edgemodders": {
     "opens": [
       { "tweakdb": { "type": "Item", "flat": "itemType", "is": "ItemType.Prt_Program" }, "command": "edgehack.openQuickhack" },
       { "tweakdb": { "type": "ObjectAction", "flat": "isQuickHack", "is": true }, "command": "edgehack.openQuickhack" },
       { "files": "**/*.quickhack.json", "command": "edgehack.openQuickhack" }
     ]
   }
   

   REDcode then shows Open in EDGEhack first on a matching record, in its TweakDB view, its record page and its search results, and a click on a quickhack opens EDGEhack. The same contract would cover EDGEwave’s sounds and EDGEmat’s materials, which are hard-coded in REDcode today. To file on REDcode once the owner agrees the shape.

Trying it in the game

Two ways, both through REDnode:

Try Live needs from REDnode (REDnode issues, to file when H4 starts):

• TweakDB writes on REDnode’s editor channel (%LOCALAPPDATA%\REDnode\editor.json), which today has only info, sound.play and sound.stop: POST /editor/tweakdb.apply with a batch of records, undone on /editor/tweakdb.reset or when the editor goes away. An in-game Allow for the editor, as planned for archives.
• A refresh of V’s quickhack list: the game caches it (PlayerPuppet.GetCachedQuickHackList, ChacheQuickHackList). Whether TweakDB changes reach an equipped quickhack without unequipping it is unverified; H4 starts with a spike.
• New icons need an archive swap (REDswap, through archives.reload); new texts in an onscreens file may need a game restart (unverified).

MCP tools

EDGEhack gets an MCP server in H4, so REDagent, and Claude Code through EDGEchat, can make and change quickhacks. Every editor feature has a tool, and every tool’s result can be opened in the editor. Agreed with the owner on 2026-11-06, with the routes and the rule below.

hack_script and hack_pack are the two names added on 2026-11-06, for what the first list lacked. Whether hack_pack wraps REDcode’s project_pack or calls REDbridge itself is settled in H4.

Two routes to the server

The server runs without VS Code, as EDGEmat’s npm package does, because REDagent runs inside the game and cannot count on an open editor.

An assistant in the game has no REDcode project open. hack_new with no project lands on the Desk (H3.7), so how REDagent’s quickhack gets from there into a project to pack is settled in H4.

Logic outside the editor

Anything a tool needs stays free of VS Code. This holds from H3.3 on, so H3 to H3c do not have to be moved apart later.

What EDGEhack depends on

New REDbridge needs, if any, are asked for as request issues on REDbridge. One is likely in H5: building an .inkatlas from images.

Phases

Each phase ends with a hand test by the owner (and an in-game test where marked); the next phase starts after it passes.

Device and vehicle quickhacks are read in H1 and edited after H3, once the people’s ones work.

H1: built

Built on 2026-11-04 in EDGEhack 0.0.2, with 0.0.3 fixing the page’s broken icons. Passed the owner’s hand test on 2026-11-04 (Tests, “H1 Read”).

Checked outside VS Code on game 2.5 through the real REDbridge (the session’s scratchpad qh/e2e.ts): the catalog in about 12 s with TweakDB’s first load, 18 families with every tier, 63 device and 4 vehicle hacks, each family read in 10 to 25 ms after that, 36 icons cut. The page rendered for Overheat and a device hack in headless Chrome (qh/pageshot.ts). 17 unit tests on made-up records.

Found while building it:

• Some items are not tiers: Items.PingLvl3Program, Items.WhistleProgram and Items.CommsCallInProgram have no action of their own (only a counterpart). The catalog leaves out an item with no action of its own, so Ping has four tiers and Bait six.
• An attack’s damage adds up several modifiers: Overheat’s tier 3 attack is 3 (the base attack’s) plus 20 (its own), 23 a hit.
• The spread is plumbing in the effect lists (SpreadInitEffector, SpreadEffector and the …HackSpread actions): the page says it in Spread and leaves it out of Effects.
• Tooltips hold the game’s placeholders ({float_0}, {int_0}), filled from stats at run time. The page shows them as they are for now.
• Three device hacks are captioned !OBSOLETE and one vehicle hack is a base record with no name; the view leaves them out.

H2: plan

Agreed with the owner on 2026-11-04. It changes three things in this design, marked below.

Numbers are written as differences (changed from “copy shared records first”). Each number the game adds up from modifiers gets one more modifier from the mod, holding the difference; the game’s own records stay as they are. The game builds its tiers the same way (QuickHack.MemoryIncreaseTier4 adds 3 RAM). This keeps the YAML short, needs no copies of shared records, and lets several mods add up rather than overwrite each other. Whether a negative difference works (RAM lowered) is the spike’s main question.

What belongs to the family, not a tier (changed from “a column per tier” for these). The game shares these records across tiers, so the page shows them once: the name, the wheel text and the wheel icon (Interactions.OverheatHack, ChoiceCaptionParts.OverheatIcon), and the cooldown. The item’s name, description and icon are set on every tier’s item from the one value. Tooltip lines stay per record, since tiers list them cumulatively.

Texts: new keys in the mod’s own onscreens file (REDbridge’s loc.newFile makes it and its .xl), named EDGEhack-<Mod>-<Field>, and written in the YAML as LocKey#EDGEhack-<Mod>-<Field>, TweakXL’s explicit form. Tooltip lines keep the game’s placeholders ({float_0}); the editor warns when one is removed.

Icons: picked from the game’s own UIIcon records. iconPath on the items, texturePartID on the wheel’s caption part.

The document’s home (changed from “on the Desk”). In H2 a document needs an open REDcode project: source/raw/edgehack/<name>.quickhack.json, with the YAML in source/resources/r6/tweaks/<mod>/<name>.yaml. The Desk comes in H3 as planned, and takes over the case of no project.

H2a’s result (2026-11-04, game 2.5): passed. The difference approach works, a negative one included, and the tooltip and the wheel show the changed numbers. LocKey#<secondary key> works.

Fixes the spike showed, for H2c: the page’s Duration must work out modifiers that read the effect’s own stats (Overheat is 5 s, not 2 s: OverheatDurationIncrease adds 3), and the page should give damage a second beside damage a tick, as the game’s tooltip does.

Steps:

The spike’s YAML, to be packed with its onscreens file:

# Numbers, as differences. Rare tier unless noted.
EDGEhack.Spike.RamUp:
  $type: gamedataStatPoolCost_Record
  statPool: BaseStatPools.Memory
  costMods: [EDGEhack.Spike.RamUpMod]
EDGEhack.Spike.RamUpMod: { $type: ConstantStatModifier, value: 2, modifierType: Additive, statType: BaseStats.Memory }
QuickHack.OverheatLvl2Hack.costs:
  - !append EDGEhack.Spike.RamUp

# The same with value -3 on QuickHack.OverheatLvl4Hack: RAM 9 becomes 6.

EDGEhack.Spike.UploadDown: { $type: ConstantStatModifier, value: -1, modifierType: Additive, statType: BaseStats.QuickHackUpload }
QuickHack.OverheatLvl2Hack.activationTime:
  - !append EDGEhack.Spike.UploadDown

EDGEhack.Spike.DamageUp: { $type: ConstantStatModifier, value: 50, modifierType: Additive, statType: BaseStats.ThermalDamage }
Attacks.OverheatQuickHackAttackLevel2.statModifiers:
  - !append EDGEhack.Spike.DamageUp

EDGEhack.Spike.DurationUp: { $type: ConstantStatModifier, value: 6, modifierType: Additive, statType: BaseStats.MaxDuration }
EDGEhack.Spike.Duration:
  $type: StatModifierGroup
  statModsLimit: -1
  statModifiers: [BaseStatusEffect.BaseOverheat_inline1, BaseStatusEffect.BaseOverheat_inline2, EDGEhack.Spike.DurationUp]
BaseStatusEffect.OverheatLevel2.duration: EDGEhack.Spike.Duration

# Texts and icons, for the family.
Items.OverheatLvl2Program.displayName: LocKey#EDGEhack-Spike-Name
Interactions.OverheatHack.caption: LocKey#EDGEhack-Spike-Name
Interactions.OverheatHack.description: LocKey#EDGEhack-Spike-Wheel
Items.OverheatLvl2Program.iconPath: quickhack_overload
ChoiceCaptionParts.OverheatIcon.texturePartID: UIIcon.OverLoad

What the spike answers:

• Does a negative difference lower RAM and upload, or does the game ignore or misread it?
• Does the wheel and the item’s tooltip show the changed RAM, upload and damage, or do some read elsewhere?
• Does LocKey#<secondary key> work on the item’s name and the wheel’s caption and text?
• Does a quickhack already in the cyberdeck pick up the change on a fresh game start?
• Do the Boss versions keep their own numbers when only the normal action changes? (The spike changes only the normal one on purpose.)
• Whichever Boss or normal action the game uses on an ordinary enemy (H1’s open question) shows here too.

H2b and H2c: built

Built on 2026-11-04 in EDGEhack 0.0.4; passed the owner’s tests, in the game too, on 2026-11-05 (Tests, “H2c Edit”).

The smoke test (npm run smoke, tools/smoke/) runs VS Code, the built extension and the real REDbridge on the game, with a stand-in REDcode holding a scratch project, and drives the pages over DevTools. It exists because of two bugs nothing else could catch: icons refused by the webview (0.0.2), and two quick changes losing one (found by its first run). Its second run passed every check. It stands in for REDcode’s Pack and Play, so the real one is for the hand test.

Two places, two numbers

Found in H2c’s in-game test (2026-11-05): Rare at 11 s and 1 s upload in the inventory read 8 s and 0.455 s in the scanner’s Hacking tab. Read in game 2.5’s scripts; the upload and duration numbers fit, but the steps below were not each measured in the game. No enemy changed these numbers. The game works them out in two ways:

So the tab’s upload includes V’s bonuses and the inventory’s does not. For duration, the inventory’s 11 s is likely the real burn, since the effect’s package gives the target those 3 s while it burns and the effect has dynamicDuration (unverified: the burn was not timed). A game Overheat should show the same split: Epic, left alone, 5 s and 2 s in the inventory, and by these formulas 2 s and 0.91 s in the tab on this save (not checked). EDGEhack’s page shows the inventory’s numbers, so the two agree there.

The player’s line (H2d): dropped

Dropped by the owner on 2026-11-04, after its second spike: “it’s fine this way”. The game’s tab stays as it is, and the Player line field is not built. What follows is kept for if it ever comes back: the first spike worked on every hack, and the second, on marked hacks only, showed no line on any hack (not looked into; likely the mark, a new flat on a game record, never read as true). The wheel text stays editable in H2c, and the page says it shows only for a hack whose tab has no effects list.

Asked for by the owner on 2026-11-04: a quickhack can give the player a short one-line description, in red, above the bullets of effects in the scanner’s Hacking tab.

The game already has this, suppressed (the owner’s idea, confirmed the same day). The tab’s layout in game 2.5 (base\gameplay\gui\widgets\scanning\scandetails.inkwidget) has a description panel beside the effects panel, in one vertical panel, in this order: damage, hackTypeWrapper, details, effects, description. Only the controller keeps them apart (QuickHackDescriptionGameController.OnQuickHackDataChanged, read in the 2.31 scripts, the class and its method in 2.5’s types): if the effects list is visible, it hides the description. The list shows when DEV_useLongScanTooltips is on and the hack has abilities to list.

So no new widget is needed, and the text is the one the record already holds (Interactions.<...>.description). It takes a very small script:

Decided by the owner on 2026-11-04, after the first spike: the line shows only on quickhacks made with EDGEhack, as a perk. The first version showed it on every quickhack, and everything fit, but the game’s own lines show their placeholders as written (Memory Wipe’s literal {float_0}) and repeat what the bullets say, which may be why the game hid them. An action shows the line when it has the flat edgehackLine: true, which EDGEhack writes on a hack with a Player line, Boss and Chimera actions included. The script puts its changes back on an unmarked hack, since the tab’s widgets are shared by every hack.

If the panels overflow (the owner’s idea, 2026-11-04: make the quickhack tooltips and panels scrollable rather than let them run off the screen). The game has scroll areas (inkScrollArea, in its full-screen menus: codex, crafting, shards, settings), but none in scandetails.inkwidget, and no tooltip or scanner script uses one. A scroll area can be added by script, as a parent of the panel, but something must drive it: the scanner’s list and the inventory’s tooltips take no scroll input of their own, and the mouse wheel and arrow keys may already move the selection in the list (unverified). Built only if the spike shows a need, panel by panel, and judged by how cluttered the screen feels in the game. The options to try, in order (the owner, 2026-11-04):

1. Automatic scrolling: a capped height with a slow scroll, needing no input.
2. A floating side panel holding only the description, so the tab keeps its size.
3. A key of its own to scroll, only if neither of those feels right.

The game’s own lines (read on 2026-11-04): the top tiers’ run from 54 characters (Reboot Optics) to 292 (Blackwall Gateway); some are flavour text rather than a description (Blackwall Gateway, Contagion, Bait), and two hold placeholders ({float_0}: Memory Wipe, Synapse Burnout) that the tab may show as written.

Built: the spike (r6/scripts/EDGEhack/PlayerLine.reds, in E:\Modding\Cyberpunk 2077\Projects\EDGEhack_H2d). The first version passed in the game on every hack; the second, on marked hacks only, waits for its run (Tests, “H2d Spike, second version”). redscript-cli found no errors in either against a copy of 2.5’s scripts. Then the field in the editor (H2c). Unverified: that TweakXL takes a new flat on a game record (edgehackLine).

H3: plan

Agreed with the owner on 2026-11-05. Read from game 2.5’s scripts and TweakDB; nothing here has run in the game yet.

A new quickhack needs more than a copy of its records. The game builds the scan’s list by matching V’s hacks against the target’s own list, by actionName: ScriptedPuppet.SendQuickhackCommands reads the character record’s objectActions, and a hack of V’s with no match shows locked. So:

The deck has its own rule, found in the spike’s first run (2026-11-05): it holds one hack of each shardType and removes any other with the same value (RemoveOtherShards), and a $base copy keeps its base’s. So a new quickhack needs its own shardType as well as its own actionName.

This changes the decision “Behaviour beyond records: out of scope”: a new quickhack needs this one script. It goes through redscript-cli against 2.5’s scripts, with and without Codeware, before any test, since one compile error stops every script in the game.

Steps:

The phase’s test stays as written: a new quickhack crafted or bought, with two added effects working on an enemy.

H3.2 built (2026-11-05): writeNewHack in src/tweaks.ts, with newHack in the document and the shared script in src/newHackScript.ts, which every EDGEhack mod ships at the same path so only one copy loads. Each tier gets its own item and action, the hack one wheel entry and cooldown, and a tier whose damage or duration changes gets copies of its status effect and of the attack’s chain (attack, effector, package). Everything goes in the record’s own body, so nothing relies on the order TweakXL applies flats in. Spread and the Boss and Chimera actions are left out, since they point at the family’s records; numbers against bosses give a warning. Run against the real REDbridge on all 18 families: all 749 game records they name exist, and a Rare Overheat’s action matches the spike’s, apart from the spike’s two added effects. Not yet run in the game: this writer’s own output, several tiers, and copied damage or duration. H3.3 tries it.

H3.3 built (2026-11-06), EDGEhack 0.0.5: Clone and Modify on the page and on a family or tier in the Quickhacks view, asking the name in VS Code’s own box (the name must make a free id, and not the one a change to a game family takes). src/projectDocs.ts finds a project’s documents, makes a new one and writes a document’s mod files, with no VS Code. The mod files are written at once, since a save of an unchanged file writes nothing and Pack and Play would find none; Pack and Play now also waits for the files of a save. The Quickhacks view’s Project group lists the project’s documents, following them on disk. The new hack’s editor drops the numbers against bosses and gives a Console line per tier until Get it (H3.6). The plan’s base field was not needed: family with newHack says the same.

H3.3 passed in the game (2026-11-06), on the owner’s laptop: the first run of the writer’s own output. A new hack made in the editor, with several tiers and copied damage and duration, sits beside the family it came from in the deck and on the wheel, with its own RAM, numbers and a 15 s cooldown of its own, while the game’s Overheat keeps its own. That settles the separate cooldown the spike could not show, since Overheat’s is 0.0001 s.

H3.4 built (2026-11-06), EDGEhack 0.0.6: Add Effect on the editor, with the picker’s two sources. src/effects.ts has the pool, the sorting, another quickhack’s effects, the warnings and resolveAdded, which reads a document’s added effects for the writer; document.ts has effects in the document, and tweaks.ts writes them. The document stores what was picked, not records per tier: status, or from and effect (the record’s name with its tier taken out). So a game patch that renames a tier’s record still resolves, and one that removes it gives a warning, not a failure.

H3.4b built (2026-11-07), EDGEhack 0.0.9: every added poison or bleed on the target (hitsMachines in src/effects.ts: statusEffectType Poisoned or Bleeding) is written as a copy on each tier, numbers changed or not, whose damage effector carries prereqRecord: EDGEhack.<id>.NotMachine, our own StatPrereq (IsMechanical LessOrEqual 0 on the Owner), written once per document (Out.notMachine in src/tweaks.ts). keptOffMachines says when it can be: applied by its status effect, with its damage in an effector of one of its packages. One that cannot, and does damage, gets a warning. The editor shows a note (the owner’s distinction: a deliberate change is a note), the card says “A copy of its own on each tier, which keeps its damage off machines”, with the tiers whose numbers changed, and the Contagion note says a copy ends without the explosion (the passive checks the game’s record names). Checked: 72 unit tests; the smoke test; the real data on game 2.5, where 34 of the pool’s poisons and bleeds are kept off machines, the 2 left do no damage, and the 93 game records the YAML names all exist. Passed in the game on 2026-11-07 (docs/testing.md, “H3.4b Machines”): a drone took only the burn, humans the poison and bleed, and with Contagion Epic in the cyberdeck the copied poison ended at the burn’s first hit with no explosion. So the game takes a $base copy of an inline effector and package, which H3.3 had left open.

Checked against the real REDbridge on game 2.5: every family as a source, 26 effects, each with every number changed, and all 355 game records the YAML names exist. Not yet run in the game: $type: ObjectActionEffect, a stacks copy, a status effect on V, and whether an added effect from another quickhack works beside the hack’s own.

What the spike answers:

• Does $base copy a tier’s inline records, or does the copy still point at the original’s?
• Does a new actionName sit beside the family it came from in the deck and on the wheel, with its own cooldown?
• Do the Boss and Chimera actions need their own new names, and how does the game pick them? (This is the design’s open question from H1.)
• Do the perks that name a family still reach a copy? Overheat’s passive and its duration stat are tied to the Overheat tag.
• Do two effects of one type stack or replace each other, and which status effects work on an enemy?

H3.1’s result (2026-11-05, game 2.5): passed. Spike Static, with its own actionName and shardType and the small script, sat beside Overheat on the wheel and worked on enemies. Both Overheat burns and the poison ran on one enemy at once, so two effects of one statusEffectType can sit side by side when they are different records, and a second upload of one record added a stack.

Still open for H3: whether $base copies inline records (the spike listed its effects by hand); how a boss’s actions are picked; and perks tied to a family.

Own icons (H3b)

Asked for by the owner on 2026-11-04: a new quickhack can have its own icons, uploaded or generated. It comes right after H3, since a new quickhack is where it is wanted. Own icons were in H5; they move here.

Each of the three icons has Pick from the game, Upload and Generate. The game draws them differently, so each look has its own pre-baked prompt, and the modder’s words are only what the glyph shows:

Generate: a click asks for text (“a skull made of static”) and sends the look’s prompt with that text to the configured service. The result shows beside the game’s icon at its real size, with Keep and Try Again; nothing is written until Keep.

Upload takes a PNG or JPG and goes through the same preview and fit. It is used as it is; a white-on-black image for Wheel or Status gets the same black-to-transparent step, offered as a switch.

Into the game: the image is fitted to the look’s size and imported as an .xbm (REDbridge’s project.import). An .inkatlas with one part per icon is written (cr2w.fromJson), and new UIIcon records point to it from the YAML. REDbridge looks enough for this; a request issue goes there if not.

Unverified, to settle in H3b: how close a fixed prompt gets to the game’s look, which needs real generated images and the owner’s eye, so the prompts will be tuned in that phase’s test; the Status look’s size; whether the atlas needs a 1080p texture as well as the 4K one the game’s have.

H3c Scripts: plan

Asked for by the owner on 2026-11-05: a quickhack can carry two REDnode functions, for what records cannot say. Agreed the same day. Read from game 2.5’s scripts; nothing here has run in the game yet.

A modder’s file:

import { quickhacks } from "rednode";

quickhacks.define("Items.EDGEhack_StaticSkullProgram", {
  canUse(target) {
    return target.isHuman;
  },
  async onLand(target, hack) {
    if (target.healthPercent < 50) await target.damage(40 * hack.tier, "Electric");
  },
});

The names and target’s fields are a first sketch. target folds the common reads and changes into one object, with api still there for the rest.

The catch in the scan check. The game builds the scan’s list in one go on its own thread, and REDnode mods run outside the game (Tier 2), so it cannot wait for an answer. A game call costs about a frame (I1 measured it). Tier 1, which could answer at once, is not built (P4). So the check asks, remembers and refreshes:

1. A small REDnode script wraps TranslateChoicesIntoQuickSlotCommands. For a hack with a check and no answer yet, it sets m_isLocked with the text “Checking” and sends REDnode an event with the target. The event carries a small snapshot (level, health, kind, tags), so a plain check needs no game call.
2. The mod’s function answers. The script remembers the answer per target and hack, and asks the game to rebuild the list (QuickhackModule.RequestRefreshQuickhackMenu, which works only while that target’s panel is open).
3. Each later rebuild shows the remembered answer and asks again, and refreshes only if the answer changed, so it cannot loop.
4. With no answer within 1 s (the mod is off, it threw, it hung), the game’s own result stands and the log says why.

The spike measured answers in 0 to 0.03 s from the snapshot, and 0.06 s with three game calls. The owner’s note from it (2026-11-05): that is too quick to read. Of the times tried, only 1 s gave enough time to notice and read “Checking”. So it holds for 1 s the first time V scans an enemy, whatever the answer, with no wait on later scans; that also keeps a usable hack locked for that second. Tried in a fight and kept by the owner on 2026-11-05. If a mod needs it shorter, a setting can come with the API. Should a future check need to be instant, the same function could move to Tier 1 with no change for modders.

On land has no such catch: nothing waits for it. A wrap on ScriptableDeviceAction.CompleteAction (people’s hacks use it, and the game skips it if the target is dead) sends the event, and the function runs a frame or two later. It adds to what the hack does and cannot cancel it. The check for a hack that should not land at all is the scan check.

Who builds what:

A mod needs REDnode only if it has a script. EDGEhack’s own requirement doesn’t change.

Steps:

What the spike answers:

• Does a locked entry with our own text behave like the game’s, and can the list be rebuilt that often without a flicker?
• Does the panel rebuild while the scan’s slow motion runs, and do REDnode’s calls keep their pace there?
• Does spread reach CompleteAction? Spread uses separate actions (…HackSpread), so onLand may need a hack.spread flag, or may not fire at all.
• Do Boss and Chimera actions reach both wraps under the family’s item?
• What makes target.damage count as V’s attack, so kills and experience go to V? A hand-built gameHitEvent crashed the game on 2026-11-05 (a null read, cause unverified): don’t use it without finding out why. Lowering the health pool with V as instigator works, and a status effect from V is the next to try.

H3c.1’s result (2026-11-05, game 2.5): passed. Both wraps and the fallback work with no REDnode change, and a locked entry shows our text as the game’s do. 90 rebuilds in about 4 minutes, with no loop. Lowering the health pool from a function works, and a kill that way looked normal. A hand-built gameHitEvent crashed the game.

Still open for H3c.2: a status effect from a function (built, not run); whose kill a function’s damage counts as (V is at the level cap, so experience could not show it); spread, not run yet, since nothing V has spread Overheat in that test (a way to spread: the Spillover perk with Overclock active, Copy-Paste, or a cyberdeck’s ability); Boss and Chimera actions.

Agreed with the owner on 2026-11-05:

• The order: the spikes H3.1 and H3c.1 in one game session, then H3, H3b, H3c, H4.
• While a check has no answer, the hack shows locked, with “Checking”.
• With no answer within 1 s, the game’s own result stands, and the log says why.
• People only for now, since devices build their list in other code and are edited after 0.1.0 anyway.
• One script per family, with the tier passed in.
• A fixed “disabled” text set in the editor, since the function returns only true or false.

A canUse that reads the game a lot is slower to answer than one using the snapshot, and the docs will say so.

Decisions

Agreed with the owner on 2026-11-04: the recommendation is the answer in each row.

Unverified, to settle in their phases

• How the game picks a quickhack’s Boss or Chimera action for a target (H1).
• Whether TweakXL takes a LocKey by an onscreens secondary key for displayName and caption, and the exact syntax (H2).
• Whether two effects of the same status effect type stack or replace each other on a target (H3).
• Which status effects work on enemies without a quest or boss state (H3, from the game’s own uses first, then in the game).
• How a new actionName reaches every enemy’s list, and whether $base copies a tier’s inline records (H3.1).
• How quickly a scan check can answer, and how “Checking” looks in the panel (H3c.1).
• Whether TweakDB changes reach an equipped quickhack without unequipping it, and how to refresh V’s cached quickhack list (H4 spike).
• Whether new onscreens texts can load without a game restart (H4).
• How a quickhack REDagent makes in the game gets from the Desk into a project to pack (H4).