66-wonderphi-compute

Valuation

Generous asset valuation: $30,000,000,000. The listed price is the platform maximum; acquisition at valuation is handled by direct enquiry.

WonderPhi Compute v1.0.0

WonderPhi Compute v1.0.0

Constitutional Parallel Runner — Put the compute back in the game.

Modern operating systems hide your compute from you. Background processes,

throttled schedulers, GPU cores that sit dark unless you know the incantation.

WonderPhi Compute is the antidote: a permanent, self-contained parallel runner

that reads a plain-text plan of shell commands and executes them across every

CPU core, honestly showing you what it's doing.

Born once. Never updated. No subscription. No telemetry. No dependencies.

What it does

Feed WonderPhi Compute a plan file — a plain-text list of shell commands,

one per line, blank lines separating parallelization barriers. WonderPhi

executes each stage across every core simultaneously, waits for the barrier,

then moves to the next stage.

$ wpc rebuild.wpc.txt

▶ WonderPhi Compute v1.0.0
  plan:       rebuild.wpc.txt
  stages:     3
  tasks:      142
  workers:    16 (cap 64, cores 16)
  gpu:        yes (exposed as $WPC_GPU to tasks)
  log:        wpc.log
  lock:       .wpc.lock

WonderPhi Compute  stage 2/3  [████████████████████░░░░░░░░░░░░░░░░░░░░]  52%   74/142 tasks
──────────────────────────────────────────────────────────────────────────────
  core  0  ▶ S2.014  ffmpeg -i input14.mov -c:v libx264 out14.mp4          (12.3s)
  core  1  ▶ S2.019  ffmpeg -i input19.mov -c:v libx264 out19.mp4          ( 8.1s)
  core  2  ▶ S2.023  pdftotext report23.pdf report23.txt                   ( 0.4s)
  core  3  (idle)
  ...

A serial script that would run for two hours finishes in ten minutes.

Why it's different

Every other parallel runner (GNU parallel, make -j, xargs -P) is a Unix tool

grown organically over decades, with a hundred configuration options and

no philosophy. WonderPhi Compute is designed the opposite way: **10 immutable

constitutional rules**, hardcoded into every binary, verified at startup, and

carved in stone. Every version of WPC that will ever exist is v1.0.0.

The constitution guarantees:

Run wpc --about to see the constitution and verify the checksum on your copy.

The plan.wpc.txt format

# WPC v1
# One shell command per line. Blank lines separate stages.

# Stage 1 — extract text from every PDF in parallel
pdftotext report001.pdf out001.txt
pdftotext report002.pdf out002.txt
pdftotext report003.pdf out003.txt

# --- barrier above ---

# Stage 2 — aggregate results (waits for stage 1)
cat out*.txt > combined.txt

# --- barrier above ---

# Stage 3 — cleanup
rm out*.txt

Rules:

• Lines starting with # are comments.
• Blank lines are stage barriers — every task above must complete before

any task below starts.

• Each non-blank, non-comment line is one shell command, executed exactly

as written by the platform shell.

• Max task length: 8 KB.
• Max tasks per plan: 65,536.

GPU awareness

WonderPhi Compute detects an NVIDIA GPU at startup (via nvidia-smi).

It does not offload work to the GPU itself — GPU offload is the job of

your individual task commands. Instead, WPC exposes $WPC_GPU=1 to every

task's environment when a GPU is present, so your commands can branch:

# in your plan file
python transcode.py input.mov out.mp4   # your script checks $WPC_GPU

This keeps WPC's constitution simple (zero CUDA dependency) while letting

you exploit the GPU when you have one.

What's in the box

wonderphi-compute/
├── wpc.exe               ← the runtime (Windows, standalone, no Python required)
├── wpc-watcher.exe       ← the always-on watcher (Windows, standalone)
├── install.ps1           ← Windows installer for always-on mode
├── uninstall.ps1         ← removes the scheduled task
├── wpc.py                ← runner source (Python, stdlib only)
├── wpc-watcher.py        ← watcher source
├── commandments.py       ← the constitution (verified at startup)
├── LICENSE               ← proprietary license, permanent
├── README.md             ← this file
├── example.plan.wpc.txt  ← ready-to-run demo
├── Makefile              ← build target for the frozen exe
└── CONTACT_INFO.txt      ← inventor contact

Always-On Mode — The Three Watchers

WonderPhi Compute ships with three cooperating watchers that turn it

into a drop-a-file-and-it-runs service. Each is a thin wrapper around

wpc.exe — none of them modify wpc.exe. The 10 Commandments and the

version 1.0.0 constitutional guarantee remain completely intact.

One-line install (Windows, no admin required):

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\install.ps1

That will:

1. Copy wpc.exe, wpc-watcher.exe, wpc-autoplan.exe, wpc-observer.exe into %USERPROFILE%\bin

2. Create all five folders: wpc-inbox\, wpc-outbox\, wpc-auto\, wpc-auto-processed\, wpc-hypotheses\

3. Register three Scheduled Tasks (one per watcher) that auto-start at every user logon

4. Start all three watchers immediately (no logout required)

After install: drop any myjob.plan.wpc.txt file into

%USERPROFILE%\bin\wpc-inbox\. Within 15 seconds, the watcher moves it

to a timestamped folder under wpc-outbox\ and runs wpc.exe there.

Both watcher-run.log and wpc.log are written into the run folder for

audit.

To verify the watcher is alive at any time:

type %USERPROFILE%\bin\wpc-watcher-status.log

To remove the always-on mode:

.\uninstall.ps1

The scheduled task is removed. wpc.exe stays where you copied it.

Running WonderPhi Compute

From source (Python 3.8+, stdlib only):

python wpc.py example.plan.wpc.txt

As a frozen executable (no Python required on target machine):

make build     # produces dist/wpc.exe (Windows) or dist/wpc (Unix)
./dist/wpc example.plan.wpc.txt

Show the constitution:

wpc --about

Validate a plan without running it:

wpc --check my.plan.wpc.txt

Purchase

WonderPhi Compute v1.0.0 is available at cri-one.com/store

for $99.00 as a permanent, one-time license.

• No subscription. No renewals. Never expires.
• Runs on Windows, macOS, and Linux.
• Every buyer receives the full source code, the frozen executable, and a

perpetual license to run it on their own equipment for the lifetime of

that equipment.

• Version 1.0.0 shall never be updated. If a future WonderPhi Compute exists,

it will be a separate SKU with its own price. This SKU stays exactly as

shipped — that's the constitutional guarantee.

Available exclusively to buyers in the United States. USD only. Email and

postal contact only — see CONTACT_INFO.txt.

Christopher Gabriel Brown

Inventor · Author · Visionary

cri-one.com

WonderPhi Compute — Benchmarks on Real Hardware

WonderPhi Compute — Benchmarks on Real Hardware

Measured 2026-07-19 on the reference workstation. Every number below is

wall-clock time from a fresh cold-cache warmup, single-run (no averaging),

using the shipped wpc.exe runtime and standard system tools. Reproduce with

the plans in benchmarks/; deltas within ~10% are normal.

The box

Test 1 — CPU parallel speedup (SHA-256)

Pure CPU-bound, memory-bandwidth-sensitive. Same 500 MB file hashed 40 times.

Serial (bash for-loop):  96.61 s
WPC parallel (64 workers): 6.84 s

Why not the full 64×: all 40 threads read the same 500 MB file

concurrently → memory bandwidth saturates before CPU does. This is a

DDR4 bottleneck, not a WPC limit. A workload with distinct per-task files

(like the shipped 541-domain healthcheck) hits 40–50× because each

worker reads independent bytes.

Verdict: WPC delivers 14× on memory-bound compute on this hardware

without any tuning.

Test 2 — 1080p H.264 encode (CPU vs. GPU)

Same 3-minute 1080p30 source (5,400 frames), 3 parallel encodes each side.

Why so close: dual Xeon at 40 cores is a powerhouse for libx264.

NVENC is fixed-function hardware with per-session setup overhead; the

speedup only pulls ahead as codec complexity increases.

Verdict: on 1080p H.264, this box's CPU is competitive with the A10M.

Use GPU when you want to keep CPU free for other work, not for raw

throughput.

Test 3 — 4K HEVC encode (CPU vs. GPU)

Same 30-second 3840×2160 30fps source (900 frames), 2 parallel encodes.

Why the GPU pulls ahead here: HEVC at 4K is far heavier than H.264 at

1080p. Software encoders (libx265) don't scale linearly with resolution

squared — but NVENC is silicon at the encode pipeline. The 4× resolution

increase penalizes CPU more than GPU.

Verdict: at 4K HEVC, the A10M is meaningfully faster than a 40-core

Xeon. The gap widens with resolution (8K would be 3–5×) and with slower

CPU presets (libx265 slow vs. hevc_nvenc p7).

Test 4 — AV1 encoding

A10M does NOT support AV1 hardware encoding. Ampere NVENC (7th gen,

2020) has H.264 + HEVC only. AV1 NVENC arrived with Ada Lovelace (2022,

RTX 40 series / L40). All AV1 results below are CPU.

Same 30-second 1080p30 source (900 frames).

Verdict on AV1: on this box, use libsvtav1, not libaom-av1. WPC's

parallelism helps for multi-file batches but yields diminishing returns

per-encode because libsvtav1 is already threaded. **A GPU upgrade to Ada

Lovelace** (L4, L40, RTX 40) would unlock av1_nvenc — expect 5–20× over

libsvtav1 in that case.

The full picture

What to use when

Why WPC exists, restated by this data

wpc.exe is a CPU parallelizer — it takes N independent commands and

runs them across every core. It does NOT accelerate individual programs;

it multiplies them. That's why the SHA-256 test shows the flagship 14×

gain: WPC turns 40 serial hashes into 40 parallel ones.

The GPU is exposed as $WPC_GPU=1 to every task's environment, so any

recipe can choose the right silicon. WPC doesn't dispatch to the GPU

itself — the recipe author does (see wpc-recipe.py's ffmpeg-nvenc and

ffmpeg-nvenc-hevc recipes in the WonderPhi Library).

Reproducing these numbers

Every plan file used above is a plain-text WPC plan. To reproduce Test 1

on your hardware:

# Create the 500 MB target
fsutil file createnew wpc-bighash.dat 524288000

# Serial baseline
time (for /L %i in (1,1,40) do @certutil -hashfile wpc-bighash.dat SHA256 >nul)

# WPC parallel
(echo # WPC v1 & for /L %i in (1,1,40) do @echo certutil -hashfile wpc-bighash.dat SHA256 ^> NUL) > hash.plan.wpc.txt
wpc hash.plan.wpc.txt

Speedup will vary with your CPU (memory-bandwidth-sensitive) and disk

cache state. First run seeds the cache; subsequent runs are ~2× faster

until reboot.

Christopher Gabriel Brown · cri-one.com

WonderPhi Session Handoff — 2026-07-18

WonderPhi Session Handoff — 2026-07-18

Checkpoint after a long build-and-ship session. Read this on the next open to

pick up cold. Everything below is either verified live or clearly labeled as

"activates on reboot."

1. What runs on your box right now

Everything's under C:\Users\crione\bin\. Status logs:

Get-Content $env:USERPROFILE\bin\wpc-observer-status.log -Tail 20 -Wait
Get-Content $env:USERPROFILE\bin\wpc-watcher-status.log  -Tail 20 -Wait

2. What's live on the store

Three connected products, all in Category 3406 (WonderPhi Driver), cross-linked

via related/upsell/crosssell in both directions:

Downloadable zips on server (all served by nginx from

/var/www/html/store/pub/media/downloadable/files/links/w/o/):

Compute has one backup file next to the live one:

wonderphi-compute-v1.0.0_1.bak-20260718.zip (previous, pre-S4U build) —

delete once you're sure you don't need to roll back.

Also live on other products from this session: App. No. 19/717,706

(+ receipt time 6:58:31 a.m. ET) is now cited on the UniPhi Complete page +

its 4 blueprint packs + UniPhi Software, across long description, short

description, and meta description. **16 duplicate ACQ-* products disabled**

(each with a live renamed twin verified first). **ACQ-18-AUTOPHI-COMBINED

restocked**.

3. Ignite on reboot — how DANGER takes over

The old safe observer (pid 18276, S4U-elevated) can't be killed from this

non-elevated shell — that's why DANGER isn't running yet. On reboot pid 18276

dies with the session. The AtLogon race between the safe task and the DANGER

task is resolved by a pre-emptive HKCU\Run entry (user-scope, no admin

needed) that fires before Task Scheduler's AtLogon triggers.

Registered entry:

HKCU\Software\Microsoft\Windows\CurrentVersion\Run
    WonderPhi-Autonomous-Compute = "C:\Users\crione\bin\wpc-observer-danger.exe"

Sequence at next reboot → logon:

1. HKCU\Run fires early in shell init → DANGER exe launches, acquires singleton.

2. Env var WPC_DANGER_AUTONOMOUS=1 (already set on user, verified) → ARMED.

3. Task Scheduler AtLogon triggers fire later:

• WonderPhi Observer (safe) launches → hits singleton → clean sys.exit(0).
• WonderPhi Observer (DANGER) launches → hits singleton → clean sys.exit(0).

4. HKCU\Run's DANGER instance keeps running.

Verify after reboot:

Get-Content $env:USERPROFILE\bin\wpc-observer-status.log -Tail 5
# expect: [DANGER] START pid=<n> DANGER OBSERVER — autonomy=ARMED
Get-Process wpc-observer-danger      # should show a live pid

4. The DANGER safety envelope (unchanged, layered)

All seven must hold before a single command auto-executes:

1. Env var WPC_DANGER_AUTONOMOUS=1 (armed via user env — persistent)

2. No file at C:\Users\crione\bin\wpc-danger-STOP (kill switch)

3. Exe on whitelist: certutil, sha256sum, md5sum, pdftotext, pandoc, magick, convert, curl, 7z (extract-only)

4. Loop prevention: never re-batch a wpc-* binary

5. Ledger dedup at C:\Users\crione\bin\.wpc-danger-ledger

6. Cooldown: 30 min per exe

7. Batch cap: 32 tasks per plan

Fail any layer → falls through to suggest-only in wpc-hypotheses\.

5. Kill switches (in order of least → most drastic)

6. Fireproofing lessons learned this session (baked into install.ps1)

• S4U vs non-elevated: S4U tasks and processes cannot be Stop-Processed

or Unregister-ScheduledTasked from a non-elevated shell. Access-denied on

all these paths: Stop-Process, taskkill /F, WMI Terminate,

Disable-ScheduledTask, schtasks /Delete, schtasks /Change /DISABLE.

• Rename-if-locked pattern: Windows permits renaming a file whose handle

is held by another process (directory-entry op), while Copy-Item Force

fails. install.ps1 now catches System.IO.IOException, renames the

live target to <name>.stale-<timestamp>, and copies the new file over.

Next reboot GCs the stale ones. Works around the S4U kill ceiling.

• PyInstaller onefile ≠ file-relative imports. wpc-observer-danger.py

originally imported wpc-observer.py via importlib.util.spec_from_file_location(_HERE/'wpc-observer.py').

When frozen, the file isn't next to the exe, and the import fails at

runtime with FileNotFoundError. Fix: inline the shared primitives

into the danger file. Duplication cost is small; independence is complete.

• HKCU\Run beats AtLogon Task Scheduler. For user-scope preemption of a

Task Scheduler race, HKCU Run fires first. Requires no admin.

7. Where the code lives

C:\Users\crione\Chris\special\66-wonderphi-compute\    ← runtime + observers
    wpc.py                       runtime (OS-range lock, constitution)
    wpc-watcher.py               inbox watcher
    wpc-autoplan.py              bulk-drop auto-planner
    wpc-observer.py              safe (suggest-only) observer w/ auto-batch mapping
    wpc-observer-danger.py       autonomous variant (7-layer envelope)
    wpc_singleton.py             cross-process singleton helper (msvcrt/fcntl)
    commandments.py              10 Commandments (frozen constants, XOR-checksummed)
    install.ps1                  fireproofed installer (rename-if-locked; S4U/Interactive auto)
    install-danger.ps1           danger installer (-Yes bypass)
    uninstall.ps1 / uninstall-danger.ps1
    Makefile                     build targets (build, build-watchers, build-all, zip)
    README.md / README-DANGER.md
    HANDOFF-2026-07-18.md        this file
    dist/                        frozen exes
    release/                     shipping zip(s)

C:\Users\crione\Chris\special\65-wonderphi-library\    ← recipe library
    wpc-recipe.py                25-recipe generator, 3 input models, GPU-aware
    README.md / INDEX.md         (INDEX auto-generated from registry)
    samples/                     curl-check example
    release/WonderPhi-Library-v1.0.0.zip

8. Not done yet (candidates for next session)

• Uninstall the safe observer task cleanly. Needs one elevated shell command:

Disable-ScheduledTask -TaskName "WonderPhi Observer". Then it won't fire

at all — cleaner than relying on HKCU\Run pre-emption. Optional; current

setup works, but this removes the noise task-launch every logon.

• Autonomous Compute exe as a build target in Makefile. Currently

invoked manually via pyinstaller.

• Tier 1 hardware-agnostic recipes (AMD AMF, Intel QSV, DirectML) — the

"as fast as the hardware open" north-star continuation. Discussed but not

built.

• Multi-machine WonderPhi Fabric — LAN-scale runner via uniphi-dc. Long

term, big lift.

9. Verification incantations

# Are the watchers up?
Get-ScheduledTask -TaskName "WonderPhi*" | ForEach-Object {
    $ti = Get-ScheduledTaskInfo $_
    "  {0,-32} state={1,-7} logon={2,-11} lastResult=0x{3:X}" -f `
        $_.TaskName, $_.State, $_.Principal.LogonType, $ti.LastTaskResult
}

# Which observer is actually active?
Get-Process wpc-observer, wpc-observer-danger -ErrorAction SilentlyContinue |
    Select-Object ProcessName, Id, StartTime

# Fire a test plan through the pipeline
"# WPC v1`necho hello-from-plan" | Set-Content "$env:USERPROFILE\bin\wpc-inbox\smoke.plan.wpc.txt"
# Watch outbox for a fresh dated folder within ~15s
Get-ChildItem "$env:USERPROFILE\bin\wpc-outbox" | Sort-Object LastWriteTime -Desc | Select-Object -First 1

Christopher Gabriel Brown · cri-one.com

WonderPhi Session Handoff — 2026-07-19

WonderPhi Session Handoff — 2026-07-19

Supersedes: HANDOFF-2026-07-18.md (kept for history).

Everything below is either verified live at the timestamp of writing or

clearly marked "requires reboot" / "requires elevated shell." Read this on

the next open to pick up cold.

1. What's live on the store — right now

Three products in Category 3406 "WonderPhi Compute" at

/store/wonderphi-compute.html,

cross-linked via related/upsell/crosssell in both directions:

Ecosystem total: $137.00 (was $219.97 yesterday — 37% impulse-buy tier cut applied today).

Downloadable files served from

/var/www/html/store/pub/media/downloadable/files/links/w/o/ as

wonderphi-{compute-v1.0.0_1,library-v1.0.0,autonomous-compute-v1.0.0}.zip.

Every push has preserved the filename and DB link_id so existing customer

download URLs remain valid.

2. What's live on the box — right now

Everything under C:\Users\crione\bin\.

3. Everything that shipped in this session (2026-07-19)

Runtime / observer fixes

• SeDebugPrivilege escalation wired into both wpc-observer.py and

wpc-observer-danger.py — ctypes.AdjustTokenPrivileges with

64-bit-HANDLE-safe signatures (see the LookupPrivilegeValueW /

OpenProcessToken argtypes; missing them silently truncated HANDLEs to 32

bits on 64-bit Python and gave misleading ERROR_INVALID_HANDLE).

• install-danger.ps1 now:
• Detects non-elevated shells and warns.
• Registers the scheduled task with -RunLevel Highest when elevated

(Limited otherwise). SeDebugPrivilege is only enable-able from a

Highest-run token, which is why the elevated install matters.

• Accepts -Yes to skip the interactive YES prompt.
• Rebuilt exes: wpc-observer.exe (8.4 MB) and wpc-observer-danger.exe

(8.4 MB), deployed. Old versions renamed to .stale-<timestamp> per

install.ps1's rename-if-locked pattern.

Kill-switch UX polish

• Renamed [PANIC] → [DISARM] and [KILL] → [STOP] in all log

entries, balloon titles, and shortcut names — softer language matching

the store's "Autonomous Compute" branding.

• Shortcut labels: "WonderPhi DISARM (pause automode).lnk" (Ctrl+Alt+K)

and "WonderPhi STOP (full stop).lnk" (Ctrl+Alt+Shift+K).

• Feedback stays non-blocking: beep + system-tray balloon, no modal

dialogs.

Benchmarks — measured on this hardware

See BENCHMARKS.md — full methodology, per-test parameters,

reproduction instructions. Hardware: **dual Xeon Gold 6138T (40 physical /

80 logical) + NVIDIA A10M (19 GB VRAM, Ampere/no AV1 HW)**.

Honest caveat on the A10M: Ampere NVENC (7th gen) has H.264 + HEVC

only, no AV1 hardware. An Ada Lovelace upgrade (L4 / L40 / RTX 40) would

unlock av1_nvenc with expected 5–20× over libsvtav1.

Store copy overhaul

• Verified performance blocks prepended to all 3 product page

descriptions in both store scopes (marker wpc-verified-perf-v1).

• Category intro rewrite at

/store/wonderphi-compute.html

— direct benefit-first framing, three product cards, verified numbers

table, honest promises (perpetual license, no telemetry, USA-only). 382

bytes of thin copy → styled multi-section HTML.

• Marker wpc-cat-intro-v1 prevents double-writes.

Impulse-buy price cut

• $149.99 → $99.00 (Compute), $19.99 → $9.00 (Library),

$49.99 → $29.00 (Autonomous).

• Updated: DB decimal prices, description/short-desc/meta-desc text

substitutions (8 rows across 3 products × 3 fields × 2 stores),

category intro price references, product-tile image banners (Library +

Autonomous PNGs regenerated with new price text).

• Reindexed catalog_product_price, catalog_product_attribute,

catalogsearch_fulltext; flushed full_page, block_html, config,

layout.

• The Compute product image is a designed graphic (700×700, centered

logo, no price banner) — inspected and left untouched.

Documentation shipped

• BENCHMARKS.md — 6.7 KB — created and bundled

inside the Compute zip so buyers get the full methodology as

post-purchase documentation.

• Compute README updated: $149.99 → $99.00 in the purchase line.
• This handoff (HANDOFF-2026-07-19.md).

4. Verified activation on this box (this morning)

The SeDebugPrivilege: ON proof from the observer's startup banner:

2026-07-19T06:27:29.971930  [DANGER] START pid=18280 DANGER OBSERVER — autonomy=ARMED
2026-07-19T06:27:29.974456  [DANGER]   SeDebugPrivilege: ON (SeDebugPrivilege enabled — cross-session CommandLine visible)
2026-07-19T06:27:29.974456  [DANGER]   whitelist: ['7z.exe', 'certutil.exe', 'convert.exe', 'curl.exe', 'magick.exe', 'md5sum.exe', 'pandoc.exe', 'pdftotext.exe', 'sha256sum.exe']
2026-07-19T06:27:29.974456  [DANGER]   cooldown=30m  max_tasks/plan=32

And a real end-to-end catch:

2026-07-19T06:33:35.655518  [DANGER] SAMPLE total=108 whitelisted_alive={curl.exe=2}

That curl.exe=2 line is the definitive proof — before the SeDebug fix,

the same sample returned whitelisted_alive={} with the exact same curl

processes running. Cross-session visibility is now real.

What's not fully proven yet: an end-to-end autoexec drop into

wpc-inbox\. The obstacle is test-methodology: whitelisted commands need

to stay alive across the observer's 60s sample cadence, and fast commands

(certutil on 500 MB completes in 2s; httpbin.org rate-limits burst

requests). Real batch workloads (100 ffmpeg encodings, 50 pdftotext runs)

easily span sample windows and will trigger autoexec naturally. A future

tuning: reduce SAMPLE_SECONDS from 60 to 15 to catch shorter jobs, at

modest CPU cost.

5. Rollback safety net

Every push made this session left a server-side backup. To restore any

prior state, one cp command:

Zip files (/w/o/)

wonderphi-compute-v1.0.0_1.bak-20260718.zip                       35e23235  pre-S4U (older)
wonderphi-compute-v1.0.0_1.bak-20260719-pre-sedebug.zip           780621fc  pre-SeDebug
wonderphi-compute-v1.0.0_1.bak-20260719-pre-bench.zip             2a820f92  pre-BENCHMARKS.md
wonderphi-compute-v1.0.0_1.bak-20260719-pre-pricecut.zip          bb240ba4  pre-pricecut
wonderphi-compute-v1.0.0_1.zip                                    3aef25d5  ← LIVE
wonderphi-autonomous-compute-v1.0.0.bak-20260719-pre-sedebug.zip  2c56146b  pre-SeDebug
wonderphi-autonomous-compute-v1.0.0.zip                           c5d0fa89  ← LIVE
wonderphi-library-v1.0.0.zip                                      f12542a1  ← LIVE (no changes today)

DB / description text

• Product descriptions: /tmp/wpc_perf_pre_<eid>_<store>.html (verified-perf prepend backups)
• Product prices in text: /tmp/wpc_pricecut_pre_<eid>_<attr>_<store>.html (8 files)
• Category intro: /tmp/wpc_cat_desc_pre_<store>.html, /tmp/wpc_cat_pricecut_pre_<store>.html

DB / prices

Restore per product: UPDATE mgcx_catalog_product_entity_decimal SET value=149.99 WHERE entity_id=32817 AND attribute_id=77 AND store_id=0; (analogous for 32818→19.99 and 32819→49.99). Reindex catalog_product_price after.

6. Ignite on reboot — still armed

Registered HKCU\Run entry so DANGER wins the singleton race at logon:

HKCU\Software\Microsoft\Windows\CurrentVersion\Run
    WonderPhi-Autonomous-Compute = "C:\Users\crione\bin\wpc-observer-danger.exe"

On next reboot → logon: HKCU\Run fires first (before Task Scheduler

AtLogon triggers), DANGER acquires the singleton, safe observer's task

launches and cleanly exits at the singleton (as designed). Verify:

Get-Content $env:USERPROFILE\bin\wpc-observer-status.log -Tail 6
# expect: [DANGER] START ... SeDebugPrivilege: ON

7. What's not done (deliberately deferred)

None of these are blockers.

• Reduce SAMPLE_SECONDS 60 → 15 for shorter-lived process detection.

Costs modest CPU; catches quick batches. Rebuild + hot-swap; next

session.

• Tier-1 hardware-agnostic recipes (AMD AMF, Intel QSV, DirectML) —

the "as fast as the hardware open" north-star continuation. Discussed,

not built.

• Multi-machine WonderPhi Fabric — LAN-scale runner via uniphi-dc.

Long term, big lift.

• Canary test recipe in the Library that self-verifies autoexec by

launching 6 slow local commands and checking for the auto-DANGER plan

drop. Would make future verification a one-command run.

8. Verification incantations

# Are the watchers up?
Get-ScheduledTask -TaskName "WonderPhi*" | ForEach-Object {
    $ti = Get-ScheduledTaskInfo $_
    "  {0,-32} state={1,-7} logon={2,-11} runLevel={3,-8} lastResult=0x{4:X}" -f `
        $_.TaskName, $_.State, $_.Principal.LogonType, $_.Principal.RunLevel, $ti.LastTaskResult
}

# Which observer is actually active?
Get-Process wpc-observer, wpc-observer-danger -ErrorAction SilentlyContinue |
    Select-Object ProcessName, Id, StartTime

# Is SeDebug on?
Get-Content $env:USERPROFILE\bin\wpc-observer-status.log -Tail 20 |
    Select-String "SeDebugPrivilege"

# Are prices live?
foreach ($url in @(
    "https://cri-one.com/store/wonderphi-compute-constitutional-parallel-runner.html",
    "https://cri-one.com/store/wonderphi-library-recipes.html",
    "https://cri-one.com/store/wonderphi-autonomous-compute.html"
)) {
    $r = (Invoke-WebRequest -UseBasicParsing $url).Content
    $price = ([regex]'<span class="price">([^<]+)').Match($r).Groups[1].Value
    "  {0} -> {1}" -f ($url -replace '.*/',''), $price
}

# Fire a smoke test through the pipeline
"# WPC v1`necho hello-from-plan" | Set-Content "$env:USERPROFILE\bin\wpc-inbox\smoke.plan.wpc.txt"
Start-Sleep 20
Get-ChildItem "$env:USERPROFILE\bin\wpc-outbox" | Sort-Object LastWriteTime -Desc | Select-Object -First 1

9. Where the code lives (unchanged from yesterday)

C:\Users\crione\Chris\special\66-wonderphi-compute\    ← runtime + observers
    wpc.py                        runtime (OS-range lock, constitution)
    wpc-watcher.py                inbox watcher
    wpc-autoplan.py               bulk-drop auto-planner
    wpc-observer.py               safe observer (SeDebug + auto-batch hypothesis emitter)
    wpc-observer-danger.py        autonomous observer (7-layer envelope + SeDebug)
    wpc_singleton.py              cross-process singleton
    commandments.py               10 Commandments (frozen constants, XOR-checksummed)
    install.ps1                   fireproofed installer (rename-if-locked, S4U/Interactive auto-detect)
    install-danger.ps1            danger installer (-Yes bypass, RunLevel=Highest when elevated)
    uninstall.ps1 / uninstall-danger.ps1
    wpc-panic.ps1                 [DISARM] hotkey handler (Ctrl+Alt+K)
    wpc-kill.ps1                  [STOP] hotkey handler (Ctrl+Alt+Shift+K)
    Makefile                      build targets
    README.md / README-DANGER.md
    BENCHMARKS.md                 measured performance report
    HANDOFF-2026-07-18.md         yesterday's checkpoint
    HANDOFF-2026-07-19.md         this file
    dist/                         frozen exes (all rebuilt today)
    release/                      shipping zips (synced to what's live on Magento)

C:\Users\crione\Chris\special\65-wonderphi-library\    ← recipe library
    wpc-recipe.py                 25-recipe generator, 3 input models, GPU-aware
    README.md / INDEX.md
    samples/
    release/WonderPhi-Library-v1.0.0.zip

What today accomplished, in one sentence

Turned WonderPhi from "promised infrastructure" into *"measured, verified,

priced-to-move product line with a working autonomous mode, sold at cri-one.com,

proven on real hardware."*

Every claim on every product page today is backed by a number we measured.

That's the difference between marketing and evidence.

Christopher Gabriel Brown · cri-one.com

WonderPhi Compute — DANGER ZONE

WonderPhi Compute — DANGER ZONE

Autonomous observer variant. Read this fully before installing.

The safe observer (wpc-observer.exe) suggests parallel plans. It watches

your process list, notices when the same program has been launched 5+ times

in a 10-minute window, writes a .plan.wpc.txt into wpc-hypotheses\, and

lets you decide whether to drag it into wpc-inbox\.

The DANGER observer (wpc-observer-danger.exe) skips the drag. When the

safety envelope is satisfied, it drops the plan straight into wpc-inbox\

where WonderPhi Compute picks it up and runs it. You will never be asked.

What this means concretely

If you run 5 SHA-256 hashes on 5 files serially, DANGER observer sees the

pattern and re-issues them in parallel. Same output, 5× faster. Fine.

If you run something that mutates state or has side effects it doesn't

warn you about — DANGER will re-run it, too, if the exe is on the

whitelist. Only run this mode when you understand which programs you're

actually launching and accept that identical commands will re-execute.

The safety envelope

Every one of these must hold before a single command auto-executes:

1. Env var WPC_DANGER_AUTONOMOUS=1 present in the task's process.

install-danger.ps1 sets it on your user account. Delete it and

auto-execution silently reverts to suggest-only.

2. Kill switch file at %USERPROFILE%\bin\wpc-danger-STOP — if it

exists, no auto-execution. Create it to disarm instantly:

   New-Item $env:USERPROFILE\bin\wpc-danger-STOP -ItemType File

3. Whitelist — only these programs' launches are eligible for

auto-execution (idempotent-safe: re-running produces the same result):

Everything else — including ffmpeg, rm/del, git, python,

or any exe not on this list — is written to wpc-hypotheses\ as a

suggestion, exactly like the safe observer.

4. Loop prevention — commands whose first token is a WonderPhi

binary (wpc.exe, wpc-watcher.exe, etc.) never auto-execute.

5. Ledger dedup — every auto-executed command is hashed to

%USERPROFILE%\bin\.wpc-danger-ledger. Identical commands never

auto-execute a second time. Delete the ledger to clear the memory.

6. Cooldown — no more than one auto-exec per exe per 30 minutes.

7. Batch cap — no auto-plan contains more than 32 tasks.

If any condition fails, the plan is written to wpc-hypotheses\ for

manual review — the safe observer's behavior.

Install / disarm / uninstall

# Install (replaces the safe observer)
.\install-danger.ps1                       # prompts you to type YES

# Instantly disarm without uninstalling
New-Item $env:USERPROFILE\bin\wpc-danger-STOP -ItemType File

# Re-arm
Remove-Item $env:USERPROFILE\bin\wpc-danger-STOP

# Full uninstall + reinstate the safe observer
.\uninstall-danger.ps1

Audit trail

Every decision (auto-executed, cooled down, whitelist-blocked, kill-

switched, deduped) is logged to %USERPROFILE%\bin\wpc-observer-status.log

with a [DANGER] prefix. Tail it live:

Get-Content $env:USERPROFILE\bin\wpc-observer-status.log -Tail 20 -Wait

What DANGER does NOT change

• The runtime constitution (wpc.exe and its 10 Commandments) is

untouched. Auto-plans go through the same watcher, same singleton

lock, same honest reporting.

• The safe observer's source code is untouched — DANGER imports

its detection primitives, not the other way around.

The only thing DANGER removes is your review step. Everything else in

WonderPhi Compute — the singleton locks, the 24-hour task caps, the

Sabbath rule, the append-only logs, the exit-code honesty — still holds.

One-line summary: if you understand exactly which programs you launch

and you're tired of dragging plans out of wpc-hypotheses\ into

wpc-inbox\, this saves you the drag. If you don't fit that

description, stay on the safe observer.

---

This archive contains 5 documents. The complete folder ships as the product.