Hackmud Toolkit – Operators Guide

buddamanx.corpscan · MIDSEC · PRIVATE

corpscan

Discovers sector listings and corporation surfaces while preserving complete-catalog history. Shared evidence remains in corp/surface/corp_surface records; the active scan cursor is caller-scoped. Starting a refresh does not hide the previous complete catalog, and promoted generations remain available to historical candidate views.

buddamanx.corpscan {run:"harvest",l:3}
buddamanx.corpscan {run:"catalog",l:3}
buddamanx.corpscan {run:"members",l:3}
buddamanx.corpscan {run:"status"}

HARVEST / RESUME – build a candidate generation

buddamanx.corpscan {run:"harvest",l:3}
buddamanx.corpscan {run:"resume"}

HARVEST captures the sector list, creates a pending generation and catalogs every owner.surface returned by those sectors. RESUME continues the fixed queue. A level is promoted only when all captured sectors were read successfully. Unresolved sectors leave the pending generation inspectable and keep the previous complete generation active. A legacy CORPDIG job, if present, is retained and can be adopted on RESUME by rescanning its captured queue.

SCAN / SECTOR – focused discovery without destroying complete state

buddamanx.corpscan {run:"scan",corp:"setec_gas",l:3}
buddamanx.corpscan {run:"sector",sector:"FORM_LAMBDA_3",l:3,corp:"setec_gas"}

SCAN performs a complete-generation pass while also learning matching corp surfaces. SECTOR is a one-sector observation: it can learn surfaces but does not change the active complete catalog pointer.

CATALOG – active complete by default

buddamanx.corpscan {run:"catalog",l:3,n:50,start:0}
buddamanx.corpscan {run:"catalog",l:3,pending:true}

Default output uses the active complete generation when one exists; legacy pre-C7 catalogs remain readable. pending:true explicitly inspects the in-progress generation and labels it PARTIAL until complete. A partial refresh is never presented as exhaustive absence.

MEMBERS – member/employee/internal candidates

buddamanx.corpscan {run:"members",l:3}
buddamanx.corpscan {run:"members",l:[2,3,4],corp:"setec_gas"}

Combines exact candidates from the active complete catalog, retained prior complete catalogs, and stored corp_surface evidence. Active rows keep the existing CATALOG labels; a candidate seen only in an older complete catalog is labeled CATALOG HISTORICAL. Stored active/historical evidence remains visible independently. Partial generations do not become history.

SHOW / PROBE – explicit revalidation writes

buddamanx.corpscan {run:"show",corp:"setec_gas"}
buddamanx.corpscan {run:"probe",corp:"setec_gas"}

SHOW and PROBE are refresh operations, not pure reads: they call scripts.get_level and update corp_surface evidence. CATALOG, MEMBERS and STATUS are read-oriented. RESET clears only the caller job; learned evidence, generations and the legacy CORPDIG record are retained.

VERSION / HELP

buddamanx.corpscan {run:"version"}
buddamanx.corpscan {run:"help"}

Detailed help is database-backed. The installed script name is CORPSCAN; old CORPDIG data IDs are retained only for compatibility and legacy-job adoption.

Reference: installed toolkit help bundle c7r2.

buddamanx.corprecon · FULLSEC · PRIVATE

corprecon

Preserves RECON repeated-read corruption merging, navigation discovery, project/user extraction and password discovery. Learned project, user and password records stay shared. Successful credentials also create a target-specific credential record without replacing the older password evidence.

buddamanx.corprecon {run:"scrape",t:#s.corp.public}
buddamanx.corprecon {run:"getpassword",t:#s.corp.public}

SCRAPE – repeated reads and evidence extraction

buddamanx.corprecon {run:"scrape",t:#s.corp.public}
buddamanx.corprecon {run:"scrape",t:#s.corp.public,n:5,raw:true}

Repeated target reads merge corrupted characters before extracting project and user evidence. The top-level execution deadline is shared; a budget-shortened scrape is labeled partial rather than silently treated as complete.

GETPASSWORD – discover directory credentials

buddamanx.corprecon {run:"getpassword",t:#s.corp.public}

Preserves the existing navigation/directory/password-key search and confirmed password evidence. A successful result also records credential:<target> with the exact navigation/password keys and creds used. LOCREPAIR consumes this route when explicit args are not supplied.

SHOW – inspect shared recon evidence

buddamanx.corprecon {run:"show",kind:"project"}
buddamanx.corprecon {run:"show",kind:"user"}
buddamanx.corprecon {run:"show",kind:"password"}
buddamanx.corprecon {run:"show",kind:"credential"}

SHOW reads stored evidence only. Credential rows are target-specific; project/user/password evidence remains shared across the discovery workflow.

VERSION / HELP

buddamanx.corprecon {run:"version"}
buddamanx.corprecon {run:"help"}

CORPRECON replaces RECON. Generated recovery commands use buddamanx.locrepair.

Reference: installed toolkit help bundle c7r1.

buddamanx.corpmembers · FULLSEC · PRIVATE

corpmembers

Preserves MEMBERHUNT user ranking, member-hit evidence, QR bit reconstruction/conflict handling and order_id recovery. The active cursor is caller-scoped; learned user/member/order evidence remains shared.

buddamanx.corpmembers {run:"start",t:#s.corp.members,pub:#s.corp.public}
buddamanx.corpmembers {run:"resume",t:#s.corp.members}
buddamanx.corpmembers {run:"status"}

START – build a caller-scoped hunt

buddamanx.corpmembers {run:"start",t:#s.corp.members,pub:#s.corp.public}

Uses CORPRECON to refresh public user evidence, then ranks stored users/member hits and begins validation against the member surface. Starting a new hunt replaces only this caller’s cursor, not shared evidence.

RESUME – continue users or QR recovery

buddamanx.corpmembers {run:"resume",t:#s.corp.members}

Resumes the fixed caller job under the shared top-level deadline. QR patterns, conflicts and order IDs are checkpointed in the job/evidence records. If the member surface rotates, the surface is marked historical and unresolved order evidence is retained.

ORDERS – hand off immediately to LOCREPAIR

When a hunt reaches DONE/PARTIAL with order IDs, the generated command uses buddamanx.locrepair {run:”cycle”,…}. LOCREPAIR reads the same caller-scoped hunt, reconstructs locs with each user/order pair and records breach_target evidence.

LEGACY / RESET

A legacy memberhunt:job is retained. If no new caller job exists, RESUME can adopt its state into corpmembers:job:<caller> without deleting the legacy source. RESET deletes only the caller-scoped cursor; member_hit, user, order_id, QR seed and legacy records remain.

VERSION / HELP

buddamanx.corpmembers {run:"version"}
buddamanx.corpmembers {run:"help"}

CORPMEMBERS replaces MEMBERHUNT; QR seed qr_data:orders is still required.

Reference: installed toolkit help bundle c7r1.

buddamanx.locrepair · FULLSEC · PRIVATE

locrepair

Preserves FIXLOC repeated-read loc reconstruction, credential/project search, direct order recovery and member-order cycles. It records breach_target evidence and prints FARM routes; it does not breach the discovered target itself.

buddamanx.locrepair {run:"fix",t:#s.target.loc}
buddamanx.locrepair {run:"direct",t:#s.target.loc,a:{order_id:"ORDER"}}
buddamanx.locrepair {run:"stats"}

FIX – credentials then known projects

buddamanx.locrepair {run:"fix",t:#s.target.loc}

When args are omitted, LOCREPAIR asks CORPRECON for credentials, then tries known projects and merges repeated corrupted loc output. Complete locs are checked with scripts.get_level and saved as breach_target evidence. Budget exhaustion emits a continuation instead of treating an unfinished project as NONE.

DIRECT – supplied complete target args

buddamanx.locrepair {run:"direct",t:#s.target.loc,a:{order_id:"ORDER"}}

Uses the supplied args directly. Intended for order/customer-service paths where the caller already has the required fields. It preserves order/run provenance in resulting breach_target records.

CYCLE – recover CORPMEMBERS orders

buddamanx.locrepair {run:"cycle",t:#s.corp.members,cycle:"HUNT_ID",ll:3}

Continues the matching caller-scoped CORPMEMBERS hunt and tries unresolved user/order pairs. Completed targets are summarized by security level. If the member surface rotates, the hunt is marked rotated and no guessed loc is adopted. Legacy memberhunt jobs remain readable for transition.

EVIDENCE / STATS

buddamanx.locrepair {run:"stats"}

Shows stored project, breach-target and target-specific credential counts. Learned projects and breach targets remain in their existing IDs; C7 changes cursors and script names, not the meaning of those shared records.

VERSION / HELP

buddamanx.locrepair {run:"version"}
buddamanx.locrepair {run:"help"}

LOCREPAIR replaces FIXLOC. Generated continuation commands use the new canonical name.

Reference: installed toolkit help bundle c7r1.

buddamanx.farm · MIDSEC · PUBLIC

farm

Public guarded orchestrator for both authorized accounts. GO resumes caller work before selecting another target. QUEUE/FS rank saved breach_target evidence. WORK calls BREACH for one supplied target. RESET delegates key-safe reset. CLEANUP previews or restores a BREACH-owned key session. C8 uses one top-level _END deadline across FARM, BREACH and lock workers; nested scripts do not renew the five-second budget.

buddamanx.farm {run:"go"}
buddamanx.farm {run:"queue",n:10}
buddamanx.farm {run:"cleanup"}

GO – resume first, then select work

buddamanx.farm {run:"go"}
buddamanx.farm {run:"go",full:true}

If the caller has a resumable breach, GO returns that work first. A pending key restoration is surfaced before new work. Otherwise it selects a HIGHSEC target (or FULLSEC with full:true) from breach_target evidence. Missing required k3ys remain held rather than guessed. GO does not cull, sell or transfer upgrades.

QUEUE – bounded ranked candidates

buddamanx.farm {run:"queue",n:10}
buddamanx.farm {run:"queue",n:10,full:true}

Ranks eligible saved targets and confirms levels while the shared deadline has room. n is capped at 25. A TIME marker means the read-only verification budget ended; rerun the command. Queue probes do not create a fresh nested deadline.

WORK – one target through BREACH

buddamanx.farm {run:"go",t:#s.target.loc,con:#s.buddamanx.utils}

Calls private BREACH using protocol 2 and passes the same absolute deadline. BREACH results drive cooldown, breached, blocked, action and resume state. Manual actions such as hardline, balance, magnara, CON_SPEC or missing k3y are printed rather than guessed.

CLEANUP / RESET – restore owned key changes

buddamanx.farm {run:"cleanup"}
buddamanx.farm {run:"cleanup",target:"corp.surface"}
buddamanx.farm {run:"cleanup",target:"corp.surface",confirm_cleanup:true}

Preview is default. Confirmed cleanup restores only serial-numbered key load-state changes owned by that breach session and never calls the target. RESET also requires successful restoration before clearing a resume. Legacy numeric indices are not adopted as key identity.

DEADLINE – one top-level execution budget

C8 uses the engine _END value as the common clock. FARM reserves return/output time and passes its absolute deadline to BREACH. A legacy numeric ms may only shorten FARM’s budget; it never extends beyond _END. BREACH passes the same or shorter deadline to LOCKT1/LOCKT2. Workers checkpoint before starting another expensive target, transaction, market or inventory call. A clean budget pause is resumable; it is not treated as key-cleanup failure.

HELP / VERSION

buddamanx.farm {run:"help"}
buddamanx.farm {run:"version"}

The public caller guard executes before help or work. Detailed help is database-backed; minimal local help remains available.

Reference: installed toolkit help bundle c8r1.

buddamanx.breach · MIDSEC · PRIVATE

breach

Private controller invoked by FARM or directly by the primary account. It calls the target, identifies each lock, delegates baseline locks to LOCKT1 and advanced locks to LOCKT2, saves resumable state, and preserves serial-numbered temporary-key recovery. C8 worker protocol 2 and a shared absolute deadline replace independently renewed timers.

BREACH / RESUME – one saved chain

buddamanx.breach {t:#s.target.loc}
buddamanx.breach {run:"resume",t:#s.target.loc}

A direct call uses the top-level _END budget. When FARM calls BREACH it supplies the already-shortened absolute deadline; BREACH may shorten but never extend it. Legacy ms may only shorten a direct run. Responses include protocol 2 for FARM and preserve lock state, arguments, answers, call timing and chain evidence.

RESULT STATES – progress, action, terminal, blocked

continue saves resumable progress. action requests explicit operator input such as hardline, balance, CON_SPEC, magnara or a missing k3y. breached/dead/busy/failed are terminal for that invocation. unsupported or stalled work is blocked/cooldown evidence rather than guessed. Budget/deadline conditions save a time resume instead of being converted into cleanup errors.

WORKERS – LOCKT1 / LOCKT2 protocol 2

BREACH calls buddamanx.lockt1 for DATA_CHECK/EZ/c00x/l0cket and buddamanx.lockt2 for sn_w_glock/acct_nt/CON_SPEC/magnara/k3y. Both workers return api:2 plus resumable state, call counts and measured target time. A worker-protocol mismatch blocks the chain rather than continuing with unknown state.

KEY SESSION – serial-number restoration

Key selection and restoration are owned by LOCKT2’s restricted key service. BREACH stores the session ID and does not infer identity from an old inventory index. Normal pauses retain verified session evidence. Cleanup/reset restores only changes owned by that session and never replays a completed target. Operator route: buddamanx.farm {run:”cleanup”}.

DEADLINE – clean budget pauses are resumable

BREACH starts no new full five-second timer. It uses _END minus reserve, or the earlier FARM deadline. Before target and worker calls it includes the largest observed target-call time plus safety margin. LOCKT2 also guards transaction-history and missing-key market lookups. If the budget is exhausted, BREACH checkpoints reason:”time” and returns continue instead of clearing recovery evidence.

HELP / VERSION

buddamanx.breach {run:"help"}
buddamanx.breach {run:"version"}

BREACH is private. Read this manual safely through buddamanx.utils {run:”help”,tool:”breach”}.

Reference: installed toolkit help bundle c8r1.

buddamanx.lockt1 · FULLSEC · PRIVATE

lockt1

Private internal worker for DATA_CHECK, EZ_21, EZ_35, EZ_40, c001, c002, c003 and l0cket. C8 renames LOCK_T1 to LOCKT1 without changing the solving tables or candidate order. It reads lock_data:core and returns worker API 2 to BREACH.

STEP – resumable worker API 2

Internal only. Input includes target scriptor, current response/args/state, lock name, shared absolute end and observed max target-call time. Output includes api:2, worker:”lockt1″, st, updated response/args/state, calls, timing and answers. continue is a checkpoint; yield means the current lock changed/unlocked; action requests hardline.

DEADLINE – no worker-local five-second timer

LOCKT1 uses the earlier of the supplied absolute deadline and _END reserve. It predicts the next target call from the observed maximum and checkpoints before starting work that cannot fit. The solver does not extend the parent invocation.

HELP / VERSION

buddamanx.lockt1 {run:"version"}

Private internal script. Operator documentation is read through buddamanx.utils {run:”help”,tool:”lockt1″}.

Reference: installed toolkit help bundle c8r1.

buddamanx.lockt2 · MIDSEC · PRIVATE

lockt2

Private internal worker for sn_w_glock, acct_nt, CON_SPEC, magnara and k3y. C8 renames LOCK_T2 to LOCKT2 while preserving the existing algorithms and serial-numbered key journal. step returns worker API 2; begin/pause/cleanup/keycheck remain the restricted key-session service used by BREACH.

STEP – resumable worker API 2

Internal step input carries target, response/args/state, lock, shared deadline and observed max target-call time. Output includes api:2, worker:”lockt2″, resumable state, timing, answers, key-session ID and key-dirty flag. Unsupported questions are surfaced; no new answer direction is guessed.

OWNED LOCKS – preserved behavior

sn_w_glock requests exact balance handling. acct_nt derives transaction candidates from account history. CON_SPEC uses generated sequence or an explicit scriptor. magnara uses learned anagram evidence. k3y selects the exact required key by value and reports the cheapest observed market listing when that key is missing. Key values are identity, not strength.

KEY SESSION – SN identity and restoration

The key service snapshots original loaded key state, resolves native indices from serial numbers immediately before sys.manage, and journals each intended/observed change. Already-loaded matching keys are preserved. Missing/changed serials or unexpected state drift stop recovery. Cleanup writes a full archive and compact RESTORED receipt before releasing the shared inventory gate.

DEADLINE – guard expensive native reads

LOCKT2 shares the parent absolute deadline. In addition to target-call prediction, C8 checkpoints before accts.transactions and missing-k3y market.browse when insufficient time remains. A KEY_BUDGET_PAUSE is treated by BREACH as resumable time pressure, not permission to clear the key session.

HELP / VERSION

buddamanx.lockt2 {run:"version"}

Private internal script. Detailed operator documentation is available through buddamanx.utils {run:”help”,tool:”lockt2″}.

Reference: installed toolkit help bundle c8r1.

buddamanx.utils · HIGHSEC · PUBLIC

utils

Inventory inspection, live highest-loaded B, verified keeper snapshots, loc repair/routing and shared utilities. C8 redirects any non-breach busy inventory gate to UPGTRADE rather than the retired MARKETSELL name.

buddamanx.utils {run:"up"}
buddamanx.utils {run:"inventory"}
buddamanx.utils {run:"snap"}
buddamanx.utils {run:"baseline",user:"buddamanx2",n:20}
buddamanx.utils {run:"cull"}
buddamanx.utils {run:"fix",loc:"<loc>"}
buddamanx.utils {run:"addmag",mag:{otsmp:"stomp"}}
buddamanx.utils {run:"route",loc:"<loc>"}
buddamanx.utils {run:"help",topic:"up"}
buddamanx.utils {run:"version"}

UP/INVENTORY/BASE/ROUTE read. SNAP/CULL write verified baseline records. CULL only prints a native command. ADDMAG and successful FIX retain their evidence writes. CON_SPEC s/d remains unchanged. No native inventory or market action is performed.

UP – inspect inventory

Reads upgrades and available system scripts. Does not reorder, load, sell, transfer, cull, or write a baseline. Optional filter and i are passed to sys.upgrades. meta:true includes serial numbers and last-use fields.

OPTIONS
filter: native upgrade filter object
i: native upgrade index selection
meta: boolean; default false

EXAMPLES

buddamanx.utils {"run":"up"}
buddamanx.utils {"run":"up","filter":{"name":"cron_bot_v1"},"meta":true}
buddamanx.utils {"run":"up","i":5}

Complete unfiltered reads include live B. Filtered/i-selected views do NOT define B; their counts describe the selection only. Raw native filters and indices are preserved. Malformed native records produce an error rather than an empty inventory. A singleton record is supported.

INVENTORY – one complete live model

buddamanx.utils {run:"inventory"}
buddamanx.utils {run:"inventory",machine:true}

Reads the initiating account once, never the secondary host inventory. B is the highest loaded index of ANY upgrade type. With no loaded upgrades, B is -1 and tail_count is null: no disposition scope is authorized. A busy gate is observational only.

Machine API 1 includes captured time, B, marker SN, serial-to-index map, protected/loaded SN sets, normalized items with preserved stats, functional/market/identity signatures and compatibility fingerprints. Signatures exclude only documented volatile fields (last_time,last_run), loaded state, index and description. Separate fields track load/order. It writes nothing; a snapshot is not permission to act.

CULL – preview a native cull command

Writes a keeper baseline, then PRINTS a native sys.cull command for indices greater than the current highest loaded index. It does NOT execute culling or transfer upgrades. No loaded upgrades: abort. This is legacy behavior, not the new trade workflow; review its printed command before ever using it.

EXAMPLES

buddamanx.utils {"run":"cull"}

C3 uses the SAME full snapshot for the saved baseline and printed indices. Active inventory work, invalid identity, or a failed baseline write blocks command generation. It remains an explicit legacy preview, not a new automatic garbage policy.

SNAP – capture keeper baseline

Writes user_loaded_upgrades:<caller> for indices 0..B, including unloaded keepers. B is the current highest loaded index. No loaded upgrades: abort. This saves a baseline; it does not change upgrades.

EXAMPLES

buddamanx.utils {"run":"snap"}

C3 uses one complete live snapshot, not a separate frozen B. Save success requires DB acknowledgment and exact readback. An active inventory gate or no loaded upgrade blocks capture. Schema 3 preserves existing baseline fields plus serial identities/marker and unknown structured stats. This does not update UPGMANAGE or sale plans.

BASE – read a saved account baseline

Reads, rather than refreshes, a saved baseline. user defaults to the initiating account and must be buddamanx or buddamanx2. n defaults to 20; all:true displays all saved keeper entries.

OPTIONS
user: allowed account; default caller
n: display count; default 20
all: boolean; default false

EXAMPLES

buddamanx.utils {"run":"baseline","user":"buddamanx2","n":20}
buddamanx.utils {"run":"baseline","all":true}

start: optional offset, default 0. n: integer 1..512. all:true includes all saved entries. These are captured account baselines, not fresh inventory or evidence of additional unique keys on the secondary.

FIX – repair and validate a location

Normalizes corruption and enumerates candidate names. Calls scripts.get_level; a valid result is saved as breach_target evidence. It does not execute the target. c is the enumeration cursor; ms defaults to 4900 in this legacy implementation. Its printed continuation must be used as supplied. Shared-deadline conversion belongs to a later coding section.

OPTIONS
loc: required location string
c: cursor; default 0
ms: legacy time allowance; default 4900

EXAMPLES

buddamanx.utils {"run":"fix","loc":"<loc>"}
buddamanx.utils {"run":"fix","loc":"<loc>","c":0,"ms":3000}

MAG – add a learned magnara answer

Writes magnara evidence after validating letters, length, and anagram signature. Conflicting saved answers are retained unless force:true is explicitly supplied. Results report added, same, conflicting and bad pairs.

OPTIONS
mag: scramble-to-word map
force: boolean; default false

EXAMPLES

buddamanx.utils {"run":"addmag","mag":{"otsmp":"stomp"}}
buddamanx.utils {"run":"addmag","mag":{"otsmp":"stomp"},"force":true}

ROUTE – inspect a target route

Reads scripts.get_level and prints an appropriate FARM command or HOLD. This route does not call the target or write target evidence. loc is required.

EXAMPLES

buddamanx.utils {"run":"route","loc":"<loc>"}

ADAPTER – preserve CON_SPEC substring counting

When both s and d are supplied, returns String(s).split(String(d)).length – 1. This compatibility adapter runs before normal help/operation dispatch, except run:”version”. It does not read inventory or the database.

OPTIONS
s: input coerced to string
d: separator coerced to string

EXAMPLES

buddamanx.utils {"s":"banana","d":"an"}

HELP – database manual and topic search

No arguments or run:”help” shows the overview. topic selects one topic. tool selects a catalogued tool and reads its manual without executing its documented command. find searches the published title/tag indexes, not every body. start defaults to 0 and n to 10. rev optionally selects an installed compatible documentation revision. Missing/incompatible data uses a small embedded fallback; version and operational paths do not depend on help data.

OPTIONS
topic: topic ID; default overview
tool: utils, libcore, upgeval, upgmanage, marketscan, upgtrade, corpscan, corprecon, corpmembers, locrepair, farm, breach, lockt1, lockt2, dbadmin, ops, storytrace, bot_brain
find: search phrase, 1..64 characters
n: page size 1..50; default 10
start: offset 0..10000; default 0
rev: optional installed documentation revision
interface: optional exact documentation interface

EXAMPLES

buddamanx.utils {"run":"help"}
buddamanx.utils {"run":"help","topic":"up"}
buddamanx.utils {"run":"help","tool":"libcore","topic":"budget"}
buddamanx.utils {"run":"help","find":"resume","n":3}

Existing c1r1 documentation is retained for historical lookup with rev:”c1r1″; current commands use c10r1. Revisions describe behavior, not the running code version.

VER – actual installed code version

Returns the version embedded in the running script without any help lookup. A manual revision is not proof of the installed code version.

EXAMPLES

buddamanx.utils {"run":"version"}

Reference: installed toolkit help bundle c10r1.

buddamanx.upgeval · HIGHSEC · PUBLIC

upgeval

buddamanx.upgeval {run:"eval"}
buddamanx.upgeval {run:"eval",all:true}
buddamanx.upgeval {run:"status"}
buddamanx.upgeval {run:"compare"}

B is the current highest loaded upgrade index, not a frozen value. 0..B is retained; every index greater than B is disposition inventory after your review. Advice never overrides placement. START is optional and no longer required by EVAL or UPGMANAGE PLAN. There is no loaded-tail HOLD case. UPGMANAGE is the permanent organizer. No transfer, sale, cull, reorder or load action.

EVAL – evaluate the current tail

buddamanx.upgeval {run:"eval"}
buddamanx.upgeval {run:"eval",all:true,n:50,start:0}
buddamanx.upgeval {run:"eval",group:"possible"}
buddamanx.upgeval {run:"eval",machine:true}

Reads complete live inventory and evaluates against 0..B. all defaults false (ordinary OTHER rows hidden); group selects all, keeper, possible, other or disposition. n defaults 100, range 1..512; start defaults 0. Continuations are NEW live evaluations; keep inventory stable while paging. b may equal live B as an assertion; any other value is rejected, never used as an override.

Duplicates remain distinct serials with retained-profile matches and tail-copy references. Equal/inferior classification is informational, not an automatic rejection or command. Multiplicity, new families/keys, strict improvements, mixed/unknown tradeoffs remain explained. Active inventory work, missing identities or no loaded boundary stop EVAL.

START – save an optional reference, not a boundary rule

buddamanx.upgeval {run:"start"}
buddamanx.upgeval {run:"start",b:64}

The explicit b example succeeds ONLY when 64 is the live highest loaded index. Captures upgeval:<caller> with a verified write/readback. Kept for compatibility; it never freezes protection. Later EVAL/STATUS/UPGMANAGE PLAN ignore saved B as authority and derive it live. Does not create an account comparison baseline; use utils SNAP for that. Active inventory gate or no loaded boundary blocks capture.

STATUS – inspect live B and the old reference

buddamanx.upgeval {run:"status"}

Displays complete live B, marker SN, counts, capacity and gate status. An old optional reference is labeled not authoritative. Missing reference is normal. No loaded upgrade is shown as B NONE with undefined tail; no state is saved. A busy gate is observed, not released.

RULES – show the actual shared comparator policy

buddamanx.upgeval {run:"rules"}

Returns policy advice2 from the worker, not a second hard-coded manual. Higher: amount,count,chars,slots,retries,max_glock_amnt,acc_mod,p2_len. Lower: cooldown,cost,expire_secs,p1_len. Unknown/mixed functional differences require review. up_class is retained metadata and does not affect functional advice. Identical structured values compare structurally; unfamiliar unequal values do not acquire guessed directions.

Tier/rarity/version do not imply functional superiority by themselves. They remain visible and in market/identity signatures. Keys compare by key value for coverage, never by text ordering as strength. Primary buddamanx holds all owned unique/apex key values.

COMPARE – saved retained sets from both accounts

buddamanx.upgeval {run:"compare"}
buddamanx.upgeval {run:"compare",left:"buddamanx2",right:"buddamanx"}

Defaults: left buddamanx, right buddamanx2; accounts must differ. Reads user_loaded_upgrades baselines, schemas 1/2/3 where complete and valid. Shows capture times, retained counts, advantages, tradeoffs, same/unique families, shared/unique key values. Retained-set matching respects multiplicity. It is NOT live inventory coverage and does not fetch the secondary inventory. Missing/stale baselines are not proof of missing upgrades. Snapshot each account only when a fresh cross-account comparison is actually needed.

MACHINE – structured results

machine:true on EVAL, STATUS, START, RULES or COMPARE returns {ok,api:1,version,data}, with code on failure. Human n/start/all/group affect formatted rows only; EVAL data retains the complete snapshot and complete tail advice. Every tail row has SN, current index, stats, class, bucket DISPOSITION, reason, matches and peers. machine does not authorize mutation. START still writes its optional reference; other listed routes are read-only.

RESET – remove only the optional reference

buddamanx.upgeval {run:"reset"}

Deletes only upgeval:<caller>, verifies acknowledgment/readback, and does not alter live B, baselines, UPGMANAGE plans, sale jobs or receipts. No upgrades are changed. Active inventory work blocks the reset. EVAL continues to work without a reference.

HELP and VERSION

buddamanx.upgeval
buddamanx.upgeval {run:"help",topic:"eval"}
buddamanx.upgeval {run:"version"}

Full docs are DB-backed and version-compatible. Missing help returns a small local fallback; no unsafe default is inferred. Version comes from the installed source. Both authorized accounts use buddamanx.upgeval; guard executes before help, DB or native reads.

Reference: installed toolkit help bundle c5r1.

buddamanx.upgmanage · MIDSEC · PUBLIC

upgmanage

buddamanx.upgmanage {run:"plan"}
buddamanx.upgmanage {run:"show"}
buddamanx.upgmanage {run:"order"}
buddamanx.upgmanage {run:"check"}
buddamanx.upgmanage {run:"reconcile"}

Replaces TEMP. B is the live highest loaded index. 0..B and B+ are separate ordering partitions. Advice remains advisory; all B+ rows are disposition after review. Confirmed ordering uses a durable job, shared inventory gate, verified archive and compact receipt. No sale, transfer or cull action.

PLAN – capture reviewed placement

buddamanx.upgmanage {run:"plan"}

Move accepted keepers into 0..B first. PLAN reads complete live inventory, derives B, evaluates advice and saves schema-5 upgmanage:plan:<caller> with serial identities, loaded set, marker and desired base/tail orders. b is only an equality assertion. The old temp:upgrade_plan record is not deleted by C4. PLAN is blocked while another inventory session owns the shared gate.

SHOW – inspect advice and disposition

buddamanx.upgmanage {run:"show",group:"disposition",all:true}

Groups: all, keeper, possible, other, disposition. Shows current index, SN, saved stats and advisory reason. Position decides disposition; duplicate or POSSIBLE advice never removes a B+ row. SHOW does not move inventory.

ORDER – preview or confirmed durable reorder

buddamanx.upgmanage {run:"order"}
buddamanx.upgmanage {run:"order",part:"tail"}
buddamanx.upgmanage {run:"order",apply:true,confirm_order:true,plan:"<id>",moves:1}

Preview is default. part is all/base/tail. Apply requires the exact plan and confirm_order:true; moves optionally caps the sequential pair count. Before sys.manage, UPGMANAGE saves the order job and owns the shared inventory gate. After the native batch it rereads inventory, verifies scope and checkpoints remaining moves. Base and tail never cross; the loaded marker at B remains anchored.

CHECK – verify plan scope

buddamanx.upgmanage {run:"check"}

Verifies exact inventory, protected base, loaded set, live B, marker and stable item identities. Order-only changes within the authorized partitions remain valid. New loot, removals, load-state changes or data changes invalidate the plan. Does not mutate inventory.

RECONCILE – inspect interrupted ordering

buddamanx.upgmanage {run:"reconcile"}
buddamanx.upgmanage {run:"reconcile",confirm_reconcile:true}

Default is read-only. It inspects the durable order job and current inventory after an interrupted or uncertain sys.manage call. If the target order is already complete, confirmation finalizes archive/receipt without replaying moves. If work remains and scope is unchanged, confirmation converts an ambiguous applying state to a resumable checkpoint and prints the order resume command. It never calls sys.manage itself. Scope changes remain blocked.

RULES – ordering policy

buddamanx.upgmanage {run:"rules"}

Base and tail are independent. Ascending: bot by retries; chat by count; lock by name; tool by k3y; script by name; script_space by stat signature then name/key. SN breaks ties. Later reorder indices are calculated from the order created by earlier pairs. up_class is metadata and does not affect functional advice.

RESET – remove only the current plan

buddamanx.upgmanage {run:"reset"}

Blocked while any inventory gate or unfinished order job exists. Removes only the canonical upgmanage plan after verified deletion. Order receipts/archives and the legacy TEMP record remain. Does not change inventory, sale jobs or receipts.

HELP and VERSION

buddamanx.upgmanage
buddamanx.upgmanage {run:"help",topic:"order"}
buddamanx.upgmanage {run:"version"}

DB-backed help with local fallback. Both authorized accounts use public buddamanx.upgmanage. The caller guard runs before help, DB or inventory work.

Reference: installed toolkit help bundle c4r1.

buddamanx.marketscan · HIGHSEC · PUBLIC

marketscan

MARKETSCAN keeps the existing k3y reconnaissance and adds caller-scoped appraisal of the current B+ inventory. APPRAISE captures the live tail and quotes unique market signatures until the execution budget is nearly exhausted. QUOTES shows the saved appraisal job. No market listing, transfer, cull, load or reorder occurs.

buddamanx.marketscan {run:"appraise"}
buddamanx.marketscan {run:"quotes"}
buddamanx.marketscan {run:"k3y"}

The public entry is guarded for buddamanx and buddamanx2. Appraisal jobs and caches live in buddamanx’s database but are caller-scoped.

APPRAISE – quote the current tail

buddamanx.marketscan {run:"appraise"}
buddamanx.marketscan {run:"appraise",fresh:true}
buddamanx.marketscan {run:"appraise",n:10,max_age:600}

A new job reads the complete live inventory, derives B as the highest loaded index, and groups every B+ item by the shared market signature. Identical signatures are quoted once and fan out to every captured serial. n caps unique signature groups for this invocation; otherwise all groups that fit are attempted. max_age is cache freshness in seconds, default 600, maximum 3600. new:true captures the current tail and may reuse valid cache. fresh:true captures a new tail and bypasses existing cache entries for that pass.

The job is read-only with respect to upgrades. A resume continues the fixed captured groups; newly acquired upgrades do not silently join it.

QUOTES – inspect saved appraisal

buddamanx.marketscan {run:"quotes"}
buddamanx.marketscan {run:"quotes",state:"quoted",n:50,start:0}
buddamanx.marketscan {run:"quotes",state:"market_error"}

Displays the captured B, policy, cache age limit, group counts, duplicate multiplicity and price evidence. States are PENDING, QUOTED, NO_MARKET and MARKET_ERROR. NO_MARKET means the shared policy found neither an exact comparable nor an approved reasonable variant. MARKET_ERROR means the market read failed or returned unusable data; it is not evidence of no market. A fresh appraisal can retry errors.

POLICY – exact then reasonable variant

Shared policy market2 is used by MARKETSCAN and by UPGTRADE’s re-quote worker. EXACT requires the same name, type, tier, rarity and functional market stats. up_class is metadata and is not part of comparable matching. VARIANT requires the same name, type, tier and rarity but may differ in ordinary functional stat values. k3y upgrades do not use cross-key VARIANT matching: different key values are different products.

Broad same-name across tier/rarity and broad TYPE matches are not automatic pricing evidence in market2. No blanket fallback is supplied by MARKETSCAN.

PRICING – inherited undercut arithmetic

The comparable floor determines the suggested ask. Below 100KGC: floor * 0.99 rounded down. At or above 100KGC: floor – 10GC. min defaults to 1GC and undercut to 10GC. MARKETSCAN records a suggestion only; it never calls market.sell. UPGTRADE still re-quotes immediately before a confirmed submission, so an appraisal is evidence, not a locked future price.

CACHE – bounded reusable quote evidence

Caller-scoped cache entries are keyed by policy, pricing options and market signature. Default freshness is 600 seconds. Duplicate inventory copies share one query. QUOTED and NO_MARKET results may be reused while fresh; MARKET_ERROR is not reused as success or absence evidence. fresh:true bypasses cache for the new appraisal pass. Caches are replaceable observations and are eligible for later retention policy, unlike permanent action receipts.

K3Y – preserve existing market key reconnaissance

buddamanx.marketscan {run:"k3y"}
buddamanx.marketscan {run:"k3y",needed:true}
buddamanx.marketscan {run:"status",all:true}
buddamanx.marketscan {run:"reset"}

This is the existing resumable k3y market scan. It records market key observations, compares them with caller-owned keys and known breach-target demand, and prints buy commands for missing values. RESET affects only the k3y scan cursor. C5 does not change the primary-account key-consolidation policy.

VERSION and HELP

buddamanx.marketscan {run:"version"}
buddamanx.marketscan {run:"help"}

The running script carries its own version. Detailed help is database-backed and may also be read without executing MARKETSCAN through:

buddamanx.utils {run:"help",tool:"marketscan",topic:"appraise"}

Reference: installed toolkit help bundle c6r1.

buddamanx.upgtrade · LOWSEC · PUBLIC

upgtrade

UPGTRADE replaces MARKETSELL. Position is authority: live B is the highest loaded index and the confirmed job captures the current B+ serials. SELL may run from either authorized account. TRANSFER is intentionally primary-only: buddamanx -> buddamanx2. Preview is optional; explicit confirmation can capture and begin a new job directly. Existing permanent MARKETSELL receipts remain in history. No culling is implemented.

buddamanx.upgtrade {run:"sell"}
buddamanx.upgtrade {run:"sell",confirm_sell:true}
buddamanx.upgtrade {run:"transfer"}
buddamanx.upgtrade {run:"transfer",confirm_transfer:true}
buddamanx.upgtrade {run:"show"}
buddamanx.upgtrade {run:"reconcile"}

SELL – direct confirmed market job

Without confirm_sell:true, SELL previews the current live tail and writes nothing. With confirmation, if no unfinished sell job exists it captures live B, protected serials and every current B+ serial, then begins immediately. The fixed job does not absorb later loot. Each item is re-quoted with market2 immediately before submission; intent and permanent receipt are verified before queue progress. Resumes carry the job ID and captured pricing policy.

buddamanx.upgtrade {run:"sell"}
buddamanx.upgtrade {run:"sell",confirm_sell:true}
buddamanx.upgtrade {run:"sell",confirm_sell:true,plan:"PLAN_ID",n:3}

NO_MARKET remains unsold without an explicit fallback. SUBMITTED means the market accepted the listing, not that a buyer purchased it.

TRANSFER – buddamanx to buddamanx2 by serial number

Primary-only. Without confirmation, previews the current buddamanx B+ tail. confirm_transfer:true captures that serial scope and transfers one serial at a time to buddamanx2. Current indices are never authorization. Each native transfer is followed by a source-inventory readback: a clear success plus source absence records TRANSFERRED; source presence records NOT_TRANSFERRED; ambiguous source absence remains blocked for reconciliation. Destination-capacity/native failures stop cleanly and retain the remaining queue.

buddamanx.upgtrade {run:"transfer"}
buddamanx.upgtrade {run:"transfer",confirm_transfer:true}
buddamanx.upgtrade {run:"transfer",confirm_transfer:true,plan:"PLAN_ID",n:5}

Calling TRANSFER as buddamanx2 is rejected. No reverse-transfer or automatic sale/cull fallback is implied.

SHOW / CHECK – inspect the active trade job

buddamanx.upgtrade {run:"show"}
buddamanx.upgtrade {run:"show",start:0,n:50}
buddamanx.upgtrade {run:"check"}

SHOW displays the captured fixed queue and current live indices when present. CHECK verifies live B/protected serials and reports pending-item presence/data drift. New B+ loot is deliberately outside an existing job. These routes do not submit listings or transfers.

HISTORY – permanent sale and transfer receipts

buddamanx.upgtrade {run:"history"}
buddamanx.upgtrade {run:"history",n:20}

Reads caller-scoped toolkit_receipt records, including earlier MARKETSELL submissions and C6 upgrade transfers. Market SUBMITTED is not SOLD. Transfer TRANSFERRED records the native success plus verified absence from the source inventory; it is not a destination-inventory audit. Detailed completed job archives are kept out of this ordinary view.

RECONCILE – inspect interrupted trade work

buddamanx.upgtrade {run:"reconcile"}
buddamanx.upgtrade {run:"reconcile",confirm_reconcile:true}

Default is read-only and waits for the original run deadline plus margin. Evidence-backed SUBMITTED or TRANSFERRED receipts can repair queue progress without repeating the native action. A transfer with no receipt may be safely marked NOT_TRANSFERRED only when the exact serial is still present on the source account. Source absence without a verified receipt remains ambiguous. Market outcomes without verified evidence remain ambiguous. BREACH and UPGMANAGE-owned gates are redirected to their own recovery routes.

RULES – position authority and market2 pricing

B is always the current highest loaded index when a new job is captured. Everything above B is eligible for the explicitly confirmed job regardless of UPGEVAL advice. The job then fixes that serial scope; new loot never joins silently.

SELL uses shared market2: EXACT then reasonable VARIANT. up_class is ignored. Different k3y values never cross-match. Below 100KGC ask is floor*0.99 rounded down; at/above 100KGC ask is floor-10GC. No blanket fallback. Read-oriented appraisal remains in MARKETSCAN, but SELL re-quotes immediately before submission.

TRANSFER is fixed to buddamanx -> buddamanx2 and uses serial numbers. No automatic cull policy exists.

RESET – archive job, retain receipts

buddamanx.upgtrade {run:"reset"}
buddamanx.upgtrade {run:"reset",confirm_reset:true}

Reset is blocked by pending recovery. Confirmation archives the current trade job before deletion. Permanent intents and receipts are retained. RESET never delists market items, reverses transfers or treats an ambiguous action as failed.

QUOTE compatibility moved to MARKETSCAN

UPGTRADE does not maintain a separate LOWSEC quote workflow.

buddamanx.upgtrade {run:"quote"}

prints the read-oriented alternatives:

buddamanx.marketscan {run:"appraise"}
buddamanx.marketscan {run:"quotes"}

Confirmed SELL still re-quotes immediately before listing.

VERSION / HELP

buddamanx.upgtrade {run:"version"}
buddamanx.upgtrade {run:"help"}
buddamanx.upgtrade {run:"help",topic:"transfer"}

UPGTRADE is PUBLIC for buddamanx and buddamanx2 but LOWSEC. The caller guard executes before help or work. Detailed help can also be read without invoking the LOWSEC executor:

buddamanx.utils {run:"help",tool:"upgtrade",topic:"transfer"}

Reference: installed toolkit help bundle c6r1.

buddamanx.ops · HIGHSEC · PRIVATE

ops

Private read-only dashboard covering discovery, breach recovery, inventory/evaluation, appraisal/trade, receipts, lifecycle health, story evidence and optional BOT_BRAIN state across both hosts. It never performs a sale, transfer, reorder, cleanup or database deletion.

DASH – bounded current summary

buddamanx.ops {run:"dash"}

Uses count/single-record queries for targets, resumes, evidence, receipts, active jobs, story-state count and caller BOT_BRAIN lab status. Archive bodies are excluded.

NEXT – smallest safe action

buddamanx.ops {run:"next"}

Prioritizes active inventory recovery, incomplete order/trade/appraisal jobs, breach resumes, CORPMEMBERS work, then new FARM work. It prints actions; it does not execute them.

MANIFEST / DEPS – both hosts

buddamanx.ops {run:"manifest",n:20}

Pages expected host, security level, access and role. BOT_BRAIN is correctly expected MIDSEC PRIVATE because its optional hardline/breach lab modes use MIDSEC actions. deps treats STORYTRACE as supported and BOT_BRAIN as optional.

AUDIT – final retirement/help check

buddamanx.ops {run:"audit"}

Checks that retired hosted names are absent, all 18 current help manuals have active pointers, no inventory gate is busy, and BOT_BRAIN has the expected optional security level. Legacy database records such as corpdig:job/memberhunt:job are reported as retained evidence, not failures.

RECEIPTS / ARCHIVES / HEALTH

buddamanx.ops {run:"receipts"}
buddamanx.ops {run:"archives"}
buddamanx.ops {run:"health"}

Receipts are compact permanent action evidence. Archive counts remain separate from routine dashboard state. health reads DBADMIN’s bounded summary.

VERSION / HELP

buddamanx.ops {run:"version"}

Detailed C10 help is database-backed. OPS remains PRIVATE and read-only.

Reference: installed toolkit help bundle c10r1.

buddamanx.dbadmin · FULLSEC · PRIVATE

dbadmin

Private database administration. Bounded health/dump, lifecycle and retention previews, verified archive/restore, help publication, and legacy preservation APIs. No automatic deletion is enabled. C10 explicitly classifies BOT_BRAIN lab state as retained configuration/evidence.

HEALTH / STATUS – bounded current state

buddamanx.dbadmin {run:"health"}

Uses count queries for current targets, resumes, receipts, jobs, busy gates, archives and help pointers. It does not scan archive bodies or mutate state.

LIFECYCLE – classify bounded records

buddamanx.dbadmin {run:"lifecycle",n:40}

Pages records by _id and labels KEEP, ARCHIVE, or CACHE. Permanent/active/unresolved/unknown records default to KEEP. story evidence and brainlab state are retained; classification is not deletion permission.

RETENTION – dry-run only

buddamanx.dbadmin {run:"retention",n:40}

Reports bounded classifications with DELETE ENABLED: NO. Completed detail requires archive first; market quote cache is future-policy only. No age threshold, scheduler, or delete command exists.

ARCHIVE / ARCHIVECHECK – verified copy

buddamanx.dbadmin {run:"archive",id:"RECORD_ID"}

Preview is default. confirm_archive:true may copy only completed-detail or cache records into a verified toolkit_admin_archive; the source is retained. archivecheck verifies body digest and source identity.

RESTORE – no overwrite

buddamanx.dbadmin {run:"restore",archive:"ARCHIVE_ID"}

Preview is default. confirm_restore:true reinserts the exact archived body only when its original _id is absent. Equal existing content is already restored; different existing content blocks restore. The archive is retained.

HELP / PRESERVATION COMPATIBILITY

helpinstall/helpcheck/helppublish retain immutable revisioned help. safety/preserve/preservecheck/history retain the earlier action-plan preservation API through UTILSFS. migrate/cutover/expire remain retired no-write compatibility routes.

VERSION

buddamanx.dbadmin {run:"version"}

DBADMIN 4.1 is the permanent database administration entry.

Reference: installed toolkit help bundle c10r1.

buddamanx.storytrace · FULLSEC · PRIVATE

storytrace

Private story investigator. TRACE records shared story_state/context evidence; QUEUE/GRAPH/SHOW inspect it. RESET only requeues a site. C10 preserves the existing parser/state schema and uses the top-level execution deadline.

buddamanx.storytrace {run:"trace",t:#s.site.loc}
buddamanx.storytrace {run:"queue"}
buddamanx.storytrace {run:"graph"}

TRACE – bounded exploration

buddamanx.storytrace {run:"trace",t:#s.site.loc}

Optional a supplies starting args; n is 1..5 and walk 1..8. ms may only shorten _END. Existing risk detection remains: submit/buy/delete/transfer/feedback/vote/signoff paths are marked RISK instead of automatically explored.

QUEUE / GRAPH / SHOW

buddamanx.storytrace {run:"queue"}
buddamanx.storytrace {run:"graph"}
buddamanx.storytrace {run:"show",site:"site.loc"}

These routes inspect saved evidence and do not call the story target.

RESET / DEADLINE / SHARING

buddamanx.storytrace {run:"reset",site:"site.loc"}

RESET requeues the root without deleting evidence. _END minus reserve is authoritative; ms can only shorten it. Story knowledge is shared by the two authorized accounts.

VERSION / HELP

buddamanx.storytrace {run:"version"}
buddamanx.storytrace {run:"help"}

Detailed help is also available through buddamanx.utils {run:”help”,tool:”storytrace”}.

Reference: installed toolkit help bundle c10r1.

buddamanx.bot_brain · MIDSEC · PRIVATE

bot_brain

Private optional cron hook retained under the required bot_brain name. It is outside normal FARM/trade automation and ships with zero static targets. Cron work requires explicit arming. Expected security is MIDSEC because hardline/breach lab modes can act.

STATUS / DISARM

buddamanx.bot_brain {run:"status"}
buddamanx.bot_brain {run:"disarm"}

STATUS shows armed mode, static-target count, index/runs and last result. An unarmed cron invocation performs no target work.

ARM – experimental authorization

buddamanx.bot_brain {run:"arm",mode:"hardline",dc:true}

Modes: hardline, call, breach. call/breach require targets compiled into static_targets(); C10 ships with none. burst is capped at 3; loop defaults false. This is a lab, not a liquidation scheduler.

CRON DEADLINE

BOT_BRAIN uses top-level _END. BREACH mode will not start another target without its minimum safe allowance and passes only a shorter ms to BREACH.

VERSION / HELP

buddamanx.bot_brain {run:"version"}
buddamanx.bot_brain {run:"help"}

The underscore is retained because cron_bot upgrades call that exact script name.

Reference: installed toolkit help bundle c10r1.

buddamanx.libcore · FULLSEC · PRIVATE

libcore

Private FULLSEC shared helper. The internal keygate API alone writes recovery state, archives, and restoration receipts. No native inventory actions. All other existing help/computation/read routes retain their behavior. Authorizes context.caller before dispatch; keygate additionally requires the actual calling_script buddamanx.lockt2. No-argument help and version remain embedded. Services return {ok,api,code,data}; failures omit data. Missing data never authorizes an action. Services: api, help, budget, gc, options, resume, bundlecheck, helpcheck, receipts, keygate. C9 catalogues DBADMIN/OPS help and the permanent admin rename.

API / VERSION

run:”api” returns the embedded version, API revision and catalogued tools. run:”version” returns the installed banner. core_api:1 requests a compatible structured service.

buddamanx.libcore {run:"api",core_api:1}

HELP / SEARCH

Supply tool:”utils”, “libcore”, “upgtrade”, “marketscan”, “upgeval”, “upgmanage”, “corpscan”, “corprecon”, “corpmembers”, or “locrepair”; topic defaults to overview. interface pins the documentation interface; rev pins an installed documentation revision. find searches bounded manifest titles/tags with n:1..50 and start:0..10000. Ordinary topic reads need an active pointer, manifest and topic, cached only in this helper during one top-level invocation. No script is called to obtain its manual.

buddamanx.libcore {run:"help",tool:"utils",topic:"up"}

C9 tools also include dbadmin and ops.

BUDGET – shared absolute deadline

Uses _END, never Date.now()+5000. reserve defaults to 750ms and must be 250..4500. Optional deadline can shorten, never extend, the allowance; need is a 0..5000ms start margin. data contains now, hard_end, deadline, remaining, can_start. Missing _END fails closed. This does not interrupt a native call or itself save job progress.

buddamanx.libcore {run:"budget",reserve:750,need:100}

GC – strict parse and format

value accepts a safe integer or a compact amount such as 1M250KGC. Whole units, descending T/B/M/K order; optional GC suffix and minus sign. Rejects fractions, junk suffixes, repeated units and unsafe integers. Returns numeric value and formatted text. Prices still require action-specific nonnegative/range validation.

buddamanx.libcore {run:"gc",value:"1M250KGC"}

OPTIONS – strict declarative fields

Supply options and spec objects. Spec supports int, bool, string and enum, with default, required, min/max or values as applicable. Unknown option keys and wrong types fail rather than coerce. At most 32 fields. This parses supplied data; it executes nothing and grants no authority.

buddamanx.libcore {run:"options",options:{n:3},spec:{n:{type:"int",min:1,max:10,default:1}}}

RESUME – render, never execute

route chooses a compiled destination: sell, transfer, quote, helpinstall or helppublish; help routes target buddamanx.dbadmin. args supplies only allowed scalar fields. Rendered resumptions require their true confirmation and a plan ID; direct confirmed UPGTRADE starts may omit plan. Emits the LOWSEC bypass, blank line and command for trade routes. The upgtrade sell/transfer routes are installed C6 contracts; the helper still only renders commands and never executes them. Every renderer result must be printed or explicitly executed by the operator; this helper never runs it.

buddamanx.libcore {run:"resume",route:"sell",args:{confirm_sell:true,plan:"example"}}

BUNDLECHECK – validate seed data

Development/bootstrap service: validates schema 1 authored topic data, interface, sizes, uniqueness, overview and module identity. Derives exact tkhelp IDs and immutable topic/manifest records. Checksums detect accidental inconsistency; they are not cryptographic authentication. Does not insert or publish anything. Seeds must be supplied by the fixed guarded release carrier, not scraped observations.

HELPCHECK – verify an installed revision

Supply tool and rev. Reads the staged manifest and every required topic afresh; returns their verified count/digest. Missing, corrupt or incompatible records fail. Reports the current active pointer without running any documented script. A shared deadline can stop verification; no pointer is changed.

buddamanx.libcore {run:"helpcheck",tool:"utils",rev:"c8r1"}

KEYGATE – restricted recovery persistence

Internal API 1 for LOCKT2, not an operator command. Actual initiating caller and actual calling_script are checked; arguments cannot impersonate them. The permanent lockt2 name and legacy lock_t2 name are accepted during compatibility. read validates the caller gate. write uses sequence-conditional updates plus acknowledgment and exact readback. record creates an immutable full key journal archive and a compact permanent restoration receipt from verified closed state. No arbitrary record keys or native load/unload operations are accepted. The state stays on buddamanx.

Market and breach share tkmarket:gate:<caller>. A busy key session blocks selling; seller reconcile redirects to public FARM cleanup instead of releasing it. Archives use toolkit_key_archive; receipts use toolkit_key_receipt, not market sale receipts. A failed write/readback leaves recovery required.

Operator preview:

buddamanx.farm {run:"cleanup"}

Inspect details through the public manual reader, without executing this API. A legacy numeric key index is not serial identity.

During the coordinated rename, the legacy private calling_script name buddamanx.lock_t2 is also accepted for rollback compatibility.

Reference: installed toolkit help bundle c9r1.

utilsfs

buddamanx.utilsfs · FULLSEC · PRIVATE

State/auth/legacy preservation helper.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.

tradecore

buddamanx.tradecore · LOWSEC · PRIVATE

Internal trade job core.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.

traderecover

buddamanx.traderecover · HIGHSEC · PRIVATE

Trade reconciliation.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.

xfercore

buddamanx.xfercore · LOWSEC · PRIVATE

Serial-number transfer worker.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.

helpdata

buddamanx2.helpdata · FULLSEC · PRIVATE

Help carrier.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.

helpseed

buddamanx2.helpseed · FULLSEC · PUBLIC

Guarded help gateway.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.

invhelp

buddamanx2.invhelp · FULLSEC · PRIVATE

UTILS help carrier.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.

managehelp

buddamanx2.managehelp · FULLSEC · PRIVATE

Management/breach help carrier.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.

markethelp

buddamanx2.markethelp · FULLSEC · PRIVATE

Trade/locrepair/bot help carrier.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.

marketlib

buddamanx2.marketlib · FULLSEC · PUBLIC

Market/model gateway.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.

scanhelp

buddamanx2.scanhelp · FULLSEC · PRIVATE

Corp/market/story help carrier.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.

upghelp

buddamanx2.upghelp · FULLSEC · PRIVATE

Upgrade/corp/lock help carrier.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.

upgmodel

buddamanx2.upgmodel · FULLSEC · PRIVATE

Inventory normalization model.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.

upgrules

buddamanx2.upgrules · FULLSEC · PRIVATE

Class-independent advisory rules.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.

upgorder

buddamanx2.upgorder · FULLSEC · PRIVATE

Deterministic sequential order helper.

Internal support; use the owning operator entry instead of invoking this worker directly. No additional operator options are invented for this reference.