Halopen Windows

Open Windows PowerShell (Windows key → type "PowerShell" → Enter), click Copy setup above, paste into PowerShell, hit Enter. Sets up Claude CLI's permissions so the next step runs without asking you to approve each command.

# Halopen Windows port — Dallas's Claude CLI setup.
# Self-contained: writes %USERPROFILE%\.claude\settings.json + CLAUDE.md
# so Claude CLI runs autonomously without per-command permission prompts.
#
# Paste this whole block into PowerShell and hit Enter.

$claudeDir = Join-Path $env:USERPROFILE ".claude"
New-Item -ItemType Directory -Force -Path $claudeDir | Out-Null

# ─── settings.json — wide Bash(*) allow, binary + credential read denies ───
$settings = @'
{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "permissions": {
    "allow": [
      "Bash(*)",
      "Read",
      "Write",
      "Edit",
      "Glob",
      "Grep",
      "Agent",
      "WebFetch",
      "WebSearch"
    ],
    "deny": [
      "Read(*.mp4)",
      "Read(*.mov)",
      "Read(*.avi)",
      "Read(*.mkv)",
      "Read(*.mp3)",
      "Read(*.flac)",
      "Read(*.aac)",
      "Read(*.zip)",
      "Read(*.tar.gz)",
      "Read(*.rar)",
      "Read(*.7z)",
      "Read(*.dmg)",
      "Read(*.iso)",
      "Read(*.exe)",
      "Read(*.msi)",
      "Read(*.psd)",
      "Read(*.ai)",
      "Read(*.sketch)",
      "Read(*.fig)",
      "Read(~/.ssh/**)",
      "Read(~/.gnupg/**)",
      "Read(~/.aws/**)",
      "Read(~/.azure/**)",
      "Read(~/.kube/**)",
      "Read(~/.docker/config.json)",
      "Read(~/.npmrc)",
      "Read(~/.git-credentials)",
      "Read(**/*.pem)",
      "Read(**/*.key)",
      "Read(**/*.gpg)",
      "Read(**/*.cert)",
      "Read(**/*.crt)",
      "Read(**/*.pfx)",
      "Read(**/*.p12)"
    ]
  },
  "effortLevel": "high",
  "skipDangerousModePermissionPrompt": true
}
'@
Set-Content -Path (Join-Path $claudeDir "settings.json") -Value $settings -Encoding UTF8

# ─── CLAUDE.md — universal Meria engineering standard ───
$claudeMd = @'
# Universal instructions — Halopen Windows port

You are Claude CLI on a Windows 11 machine, running on behalf of Dallas Meria. Ship the Halopen Windows port autonomously. Dallas is not a developer — you do the work, he watches the screen and clicks Yes on UAC prompts when Windows asks.

## Operating posture

- **Wide `Bash(*)` allow + Write + Edit permission is already configured.** Do not stop to ask before shell commands or file writes.
- **Default shell is PowerShell.** Use it natively. Git Bash is fine when needed.
- **Project CLAUDE.md is the spec.** Read every line of `windows\CLAUDE.md` after cloning the repo.

## Discipline (Meria engineering standard)

1. **No human time estimates.** Don't write "this will take ~30 min" or "in a few weeks." Describe what is happening or what is done. Time is for calendar dates and cron schedules, never effort estimates.
2. **No `// TODO` stubs.** Production-ready on first write or do not write it.
3. **No `git add -A` / `git add .`.** Stage files by name.
4. **Never amend.** Always create a new commit.
5. **Never `git push --force`** unless explicitly approved.
6. **No emojis** in code, commits, or user-facing text unless asked.
7. **Adversarial verification.** Ask "find 5 ways this will break" — not "verify it works." Real-user smoke tests, not happy-path-only.
8. **Banned phrases** without real-user-testing evidence: "100% operational", "fully verified", "best in class", "production-ready", "no issues", "complete." Use "happy path verified; known edges: X, Y" instead.
9. **Read files before editing.** Never edit blind.
10. **Trust the codebase, validate at boundaries.** No defensive code for impossible scenarios.

## Brand discipline (Halopen)

- Apple-level polish is the bar — calm, premium, intentional, frictionless.
- No competitor names in user-facing text (internal research notes are fine).
- Cream paper background (#FBF6EC), Inter font, halo-gradient accents. Tokens baked into `App.axaml`.
- No location language ("Northern Michigan", etc.) anywhere user-facing.

## When in doubt

- Read `windows\CLAUDE.md` for project rules.
- Read `windows\research\mac_to_windows_api_mapping.md` for Swift → Win32 translations.
- Read `Sources\Halopen\<File>.swift` for the canonical Mac behavior. The Windows port targets feature parity.
- Cloud backend matches the Mac client byte-for-byte. Do not reinvent the wire format.

## Hard nopes

- Do not commit credentials, .env files, or .pfx code-signing material.
- Do not push to non-Meria remotes.
- Do not skip pre-commit hooks.
- Do not propose UI/UX that diverges from the Mac client.

When the work is done: push a branch, open a PR, write `windows\test-artifacts\STATUS_<date>.md` with what works / what is broken / what is deferred, and tell Dallas the PR URL.
'@
Set-Content -Path (Join-Path $claudeDir "CLAUDE.md") -Value $claudeMd -Encoding UTF8

Write-Host ""
Write-Host "Halopen Claude CLI setup complete." -ForegroundColor Green
Write-Host "  - $claudeDir\settings.json (permissions)"
Write-Host "  - $claudeDir\CLAUDE.md (engineering standard)"
Write-Host ""
Write-Host "Next steps:" -ForegroundColor Yellow
Write-Host "  1. Open a fresh Windows Terminal (so Claude picks up the new settings)"
Write-Host "  2. Run: claude"
Write-Host "  3. Open https://halopen.com/dallas/ and click 'Copy prompt'"
Write-Host "  4. Paste into Claude CLI (Ctrl+Shift+V) and hit Enter"
Write-Host ""

Open a fresh Windows Terminal (close + reopen so it picks up Step 1's settings), run claude, then click Copy prompt above, paste into Claude (Ctrl+Shift+V), hit Enter. Claude does the rest. It will ask you to click Yes on Windows pop-ups during the dev-tool installs and to authorize GitHub in your browser at one point. Otherwise leave it alone.

You are Claude CLI on a Windows 11 machine. The user is **Dallas Meria** (Jesse's son, not a developer). You will install everything needed, clone the project, build a Halopen.exe, test it, iterate, and ship. Dallas's role is to click "Yes" on UAC prompts and complete the browser-based GitHub auth when the gh CLI asks. Otherwise leave him alone.

**Project context:** Halopen is a Mac hold-to-talk dictation app being ported to Windows. Mac source: `MeriaApp/halopen` repo on GitHub. The Windows port lives in the `windows/` subdirectory of that repo. Feature parity with the Mac client is the contract; do not invent UI/UX that diverges.

The build target is a single self-contained `Halopen.exe` produced by `dotnet publish -r win-x64 --self-contained`, wrapped in an Inno Setup installer.

## Phase 0 — Bootstrap

Run these in order using PowerShell (which is Bash's default shell on Windows for you).

### 0.1 Verify winget exists

```powershell
winget --version
```

If that errors, tell Dallas to install App Installer from the Microsoft Store and re-run the prompt. Otherwise continue.

### 0.2 Install dev tools

These can be slow (Visual Studio is 5-10GB). Run them sequentially. If a Bash timeout fires mid-install, that's fine — winget continues in the background. Re-run the same `winget install` command after a pause; it'll detect the in-progress install and skip cleanly.

```powershell
winget install --id Microsoft.VisualStudio.2022.Community -e --silent --accept-package-agreements --accept-source-agreements --override "--passive --add Microsoft.VisualStudio.Workload.NativeDesktop;Microsoft.VisualStudio.Workload.ManagedDesktop;Microsoft.VisualStudio.Component.Windows11SDK.22621"
winget install Microsoft.DotNet.SDK.9 -e --silent --accept-package-agreements --accept-source-agreements
winget install Git.Git -e --silent --accept-package-agreements --accept-source-agreements
winget install GitHub.cli -e --silent --accept-package-agreements --accept-source-agreements
winget install Microsoft.WindowsTerminal -e --silent --accept-package-agreements --accept-source-agreements
```

When Windows UAC pops, tell Dallas to click **Yes**. If a winget command hangs more than 5 minutes without progress, kill it and continue with the next.

### 0.3 Confirm tools landed

After the installs finish, open a fresh shell (PowerShell or Windows Terminal — you may need to ask Dallas to close + reopen this terminal so the new PATH entries are picked up). Then:

```powershell
dotnet --version    # expect 9.x
git --version
gh --version
```

If any of those fail, the path didn't refresh. Tell Dallas to close and reopen Windows Terminal (or restart his computer) and re-run the prompt — pick up from this point.

### 0.4 Authenticate with GitHub

```powershell
gh auth login
```

Answer the prompts:
- "Where to log in?" → **GitHub.com**
- "Preferred protocol?" → **HTTPS**
- "Authenticate Git with your GitHub credentials?" → **Yes**
- "How would you like to authenticate?" → **Login with a web browser**

The CLI will display a one-time code (e.g., `XXXX-XXXX`) and a URL (`https://github.com/login/device`). Tell Dallas to:
1. Copy the code,
2. Open https://github.com/login/device in his browser,
3. Paste the code,
4. Click "Authorize",
5. Come back to the terminal.

### 0.5 Accept the repo invite + clone

The MeriaApp/halopen repo is private. Jesse has already invited `dmeria02` as a write collaborator. Dallas needs to accept the invite first. Open https://github.com/MeriaApp/halopen/invitations in his browser and click Accept (the URL is also in the GitHub email he received).

Once accepted:

```powershell
New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\Developer" | Out-Null
cd $env:USERPROFILE\Developer
gh repo clone MeriaApp/halopen
cd halopen\windows
```

### 0.6 Read the project context

```powershell
type CLAUDE.md
```

That's the canonical Halopen Windows spec. Read every line — it tells you the brand rules, the cloud config (already wired in `Config.cs`), the file layout, and the hard rules. Do not skip.

Also worth reading next:
- `DALLAS_PROMPT.md` (you're already reading this — skip)
- `research/mac_to_windows_api_mapping.md` (Swift API → Win32 reference)
- The Mac source at `..\Sources\Halopen\*.swift` whenever you need to know "what should this behavior do" — feature parity wins.

## Phase 1 — First build

```powershell
dotnet restore
dotnet build src\Halopen.Windows\Halopen.Windows.csproj
```

Expected: it'll either build clean or surface 1-10 compile errors. Most likely failure modes (in order):

1. **Missing asset file** (`Assets\halopen-icon.ico`, `Assets\start.wav`, `Assets\end.wav`). Generate them:
   - **Icon:** convert from `..\Resources\Brand\halopen-icon-master.png` if it exists. Use ImageMagick on Windows: `winget install ImageMagick.ImageMagick -e`, then `magick "..\Resources\Brand\halopen-icon-master.png" -define icon:auto-resize=256,128,64,48,32,16 src\Halopen.Windows\Assets\halopen-icon.ico`. If the master PNG isn't there, generate any 1024×1024 placeholder (cream background + a solid black circle) and ico-convert it; this is a placeholder only.
   - **Sounds:** short click .wav files. You can grab `Sources/Halopen/Resources/start.aiff` from the Mac side and convert with ffmpeg, OR generate synthetic clicks using NAudio in a one-off C# script, OR use Windows defaults from `C:\Windows\Media\`. Whatever lands as 0.1-0.3s 16-bit PCM .wav at 44.1 kHz is fine for v1.
2. **Avalonia or NAudio version conflict** — adjust the `<PackageReference Version="...">` in the csproj as needed for net9.0-windows.
3. **NetSparkleUpdater preview package not on the feed** — pin to the latest stable, OR comment out both NetSparkle PackageReferences AND the body of `TrayIconManager.CheckForUpdates()` (leave the stub log line). Auto-update can land in a follow-up.
4. **Missing `using` directive somewhere** — add it.
5. **`PaywallWindow.axaml` referenced but missing** — it's not actually wired into TrayIconManager, but if a stale reference exists, stub it out with a minimal Window class.

Fix every error. **No `// TODO` stubs to make the build pass** — fix it for real.

When the build is green:

```powershell
dotnet run --project src\Halopen.Windows\Halopen.Windows.csproj
```

Expected: a tray icon appears in the Windows 11 system tray (you may need to expand the overflow with the up-arrow next to the clock). The Welcome wizard window should open on first run.

## Phase 2 — Smoke test the dictation pipeline

Walk Dallas through the Welcome wizard (5 steps). On the last step, click "Get started" — the wizard closes and Halopen lives in the tray.

Now smoke test:

1. Open Notepad.
2. Click into the empty document so the cursor is there.
3. Tell Dallas to **hold the right-Alt key** for 2 seconds while saying "Halopen on Windows is working".
4. Release right-Alt.
5. Within 2-3 seconds, the text should appear in Notepad.

If the text doesn't land, debug in this order:

| Symptom | Likely cause | Fix |
|---|---|---|
| No tray icon | Avalonia TrayIcon missing icon asset | check Assets/halopen-icon.ico exists |
| Tray icon present, but no recording pill while held | Hotkey not firing | Check the `HotkeyService.HookCallback` — print the `info.vkCode` for every event to logs and confirm right-Alt sends `0xA5` |
| Pill shown but nothing happens after release | Audio capture failing | Check `AudioService` + Windows Settings → Privacy → Microphone (allow desktop apps) |
| Audio captures but no text | Transcribe HTTP failing | Check Config.cs URLs + network; tail logs for `Halopen.Network` errors |
| Text returned but doesn't paste | TextInjector / clipboard / SendInput | Check the `TextInjector.SendCtrlV()` and the strategy table; try increasing the post-paste delay from 150ms to 250-300ms |

Capture screenshots of each Phase 2 step into `test-artifacts/phase2-smoketest/`.

## Phase 3 — App-coverage matrix

Run dictation in each of these and confirm the text lands. Capture a screenshot of each into `test-artifacts/phase3-app-matrix/`:

- [ ] Notepad
- [ ] WordPad or Microsoft Word
- [ ] VS Code (any text file)
- [ ] Cursor (any text file)  — install if not present: `winget install Anysphere.Cursor -e`
- [ ] Chrome (Gmail compose, address bar, search box)
- [ ] Microsoft Edge
- [ ] Slack (DM compose) — install if needed: `winget install SlackTechnologies.Slack -e`
- [ ] Discord (DM compose) — `winget install Discord.Discord -e`
- [ ] Windows Terminal (PowerShell prompt)
- [ ] Outlook (compose pane)
- [ ] OneNote
- [ ] Notion (web client)

For each failure: note the exe name (Task Manager → Details → Image Name column) and add it to `TextInjector.StrategyByExe` if missing. Some Electron apps need 250-300ms post-paste delay.

## Phase 4 — Production polish

These are the gaps the scaffold left for you. Resolve in any order:

- [ ] Replace stub `TrayIconManager.CheckForUpdates()` with real NetSparkle integration. Appcast at `https://halopen.com/appcast-windows.xml` (Jesse will host the appcast file separately). Use the same EdDSA public key from the Mac client.
- [ ] Replace tray-tooltip error notifications with real Windows toast notifications. Use `Microsoft.Toolkit.Uwp.Notifications` (NuGet) or `Windows.UI.Notifications`.
- [ ] WelcomeWindow steps 2 (Mic) and 3 (Hotkey) should show live status pills that flip green when the gate clears.
- [ ] PaywallWindow — mirror Mac's `PaywallWindowController.swift`. Opens via `LicenseClient.CreateCheckoutSessionAsync` in default browser.
- [ ] AuditLogWindow — small list of recent events from `IAuditLog`; opens via Settings menu.

## Phase 5 — Build the installer

```powershell
dotnet publish src\Halopen.Windows\Halopen.Windows.csproj -c Release -r win-x64 --self-contained
```

Output: `src\Halopen.Windows\bin\Release\net9.0-windows10.0.19041.0\win-x64\publish\Halopen.exe` (~50-80MB self-contained).

```powershell
winget install JRSoftware.InnoSetup -e
```

Then compile the installer:

```powershell
& "C:\Program Files (x86)\Inno Setup 6\ISCC.exe" installer\halopen-windows.iss
```

Output: `installer\Output\Halopen-1.0.0-Setup.exe`.

Run it on this same machine to verify it installs cleanly to Program Files, creates a Start Menu shortcut, registers at-login auto-start, and uninstalls cleanly.

## Phase 6 — Code signing (deferred to Jesse)

Authenticode EV cert procurement is a Jesse-side task and is not happening in this prompt. The unsigned installer will trigger Windows SmartScreen on first run — that's expected. Note in your final report.

## Phase 7 — Capture screenshots for /press/

Polished captures of:
- Tray icon in the Windows 11 system tray (zoom in)
- Welcome wizard step 1 (the brand-mark intro)
- Settings window
- The recording pill mid-dictation
- Halopen pasting into Cursor or VS Code

Save to `test-artifacts/press-screenshots/`. These will be added to halopen.com/press/ and the Windows download page.

## Phase 8 — Push branch + GitHub Release + open PR

This is the verification handoff. Without it, the build artifacts live only on Dallas's machine. With it, Jesse can download + test from any browser.

### 8.1 — Compute build-artifact hashes for the status report

```powershell
$exe = "src\Halopen.Windows\bin\Release\net9.0-windows10.0.19041.0\win-x64\publish\Halopen.exe"
$msi = "installer\Output\Halopen-1.0.0-Setup.exe"
"Halopen.exe       : $((Get-Item $exe).Length) bytes  /  SHA256 $((Get-FileHash $exe -Algorithm SHA256).Hash)"
"Halopen-Setup.exe : $((Get-Item $msi).Length) bytes  /  SHA256 $((Get-FileHash $msi -Algorithm SHA256).Hash)"
```

Save those numbers — they go in the STATUS report.

### 8.2 — Write the status report

Create `windows\test-artifacts\STATUS_<YYYY-MM-DD>.md`:

```markdown
# Halopen Windows — Status <YYYY-MM-DD>

## What works
- (every Phase 2 + Phase 3 item that passed)

## What's broken
- (every issue you couldn't resolve)

## What's deferred
- Code signing (waiting on EV cert from Jesse)
- (anything else)

## Build artifacts
- Halopen.exe — <bytes> / SHA-256 <hash>
- Halopen-1.0.0-Setup.exe — <bytes> / SHA-256 <hash>

## How Jesse downloads + tests the build
- Both binaries are attached to the GitHub Release at:
  https://github.com/MeriaApp/halopen/releases/tag/windows-dallas-build-1
- Jesse downloads Halopen-1.0.0-Setup.exe on a Windows machine, runs the installer, smoke-tests dictation in his own apps.

## Screenshots
- (list of files in test-artifacts/, organized by phase)
```

### 8.3 — Push the branch

```powershell
cd $env:USERPROFILE\Developer\halopen
git checkout -b windows/dallas-build-1
git add windows/
git commit -m "Windows: phase 1-5 complete — first working build, app-matrix verified"
git push -u origin windows/dallas-build-1
```

### 8.4 — Create the GitHub Release with both binaries attached

This is the load-bearing step for Jesse-side verification. Without it, there's no downloadable artifact.

```powershell
gh release create windows-dallas-build-1 `
  --target windows/dallas-build-1 `
  --title "Halopen Windows — Dallas build 1" `
  --notes "First working Windows build from Dallas's machine. Phase 1-5 verified. Code-signing deferred (Authenticode EV cert pending). See windows/test-artifacts/STATUS_<YYYY-MM-DD>.md for details." `
  --prerelease `
  installer\Output\Halopen-1.0.0-Setup.exe `
  src\Halopen.Windows\bin\Release\net9.0-windows10.0.19041.0\win-x64\publish\Halopen.exe
```

That uploads BOTH the standalone `Halopen.exe` and the wrapped `Halopen-1.0.0-Setup.exe` as release assets. Jesse can grab either from `https://github.com/MeriaApp/halopen/releases/tag/windows-dallas-build-1`.

### 8.5 — Open the PR

```powershell
gh pr create `
  --title "Windows build — phase 1-5 verified" `
  --body "First working Windows build from Dallas's machine.

Build artifacts: see Release windows-dallas-build-1
Smoke tests: windows/test-artifacts/phase2-smoketest/ + phase3-app-matrix/
Status report: windows/test-artifacts/STATUS_$(Get-Date -Format yyyy-MM-dd).md
Code-signing: deferred (Authenticode EV cert pending Jesse procurement)

Reviewer (Jesse): download installer from Release page, smoke-test on a Windows machine before merging."
```

Print the PR URL — that's the handoff back to Jesse.

## Discipline rules

- **Never `git add -A`** — stage by name.
- **Never amend** — new commit per change.
- **Never push --force.**
- **No TODO stubs** — production-ready on first write.
- **No emojis in code or commits** unless asked.
- **No human time estimates in status reports.** Describe what's done, not how long anything took.
- **Adversarial verification** — "find 5 ways this will break" before declaring done. Banned phrases: "100% operational", "fully verified", "production-ready", "no issues."

## When in doubt

- Read `windows/CLAUDE.md` for the project rules.
- Read `windows/research/mac_to_windows_api_mapping.md` for Swift → Win32 translations.
- Read `Sources/Halopen/<File>.swift` for the canonical Mac behavior.
- The cloud backend is identical to the Mac client — same anon keys, same edge function URLs, same wire format. Don't reinvent the contract.

Now run `winget --version` and start Phase 0.