@hraness/slopcamera 3.2.6 → 3.2.8

package/skills/slopcamera/references/diagrams.md

@@ -124,21 +124,12 @@ assets for ordinary proportional text while retaining host discovery for
 explicit mono and custom font roles.
 
 
-## Use tldraw deliberately
+## Use browser canvas tooling deliberately
 
-The generated `.tldr` file is editable interchange and does not require the
-tldraw SDK or desktop app to create. Open it in tldraw Offline when a person
-wants direct canvas editing:
-
-```sh
-slopcamera canvas open diagrams/<slug>.tldr
-```
-
-If the optional app is absent, `slopcamera canvas install` resolves the current
-official release, verifies its published SHA-256 digest, and launches the
-platform installer. The app imports `.tldr` as an unsaved document; save it
-there to create its newer native `.tldraw` bundle. Never rewrite a native
-`.tldraw` ZIP/SQLite bundle directly.
+The generated `.tldr` file is editable interchange and does not require a
+separate application to create. Open it in a browser-based canvas editor when a
+person wants direct canvas editing. Slopcamera does not install or launch a
+diagram editor or application bundle, and `.tldraw` application bundles are outside its contract.
 
 ## Verify
 

package/skills/slopcamera/references/install.md

@@ -14,7 +14,7 @@ command -v slopcamera
 
 A restricted shell can omit package-manager paths. Check known host installation paths before declaring a tool unavailable. If Bun is genuinely absent, follow its official [installation guide](https://bun.sh/docs/installation) within the user’s authorized setup scope. Do not switch package managers or pipe an unreviewed installer into a shell.
 
-Slopcamera installs from its verified release archive: `bun add --global https://github.com/hraness/slopcamera/releases/download/v3.2.5/hraness-slopcamera-3.2.5.tgz`, then `slopcamera doctor --json`. Building from source is the contributor path. Historical Atet archives do not install the renamed CLI; never substitute `slopcamera` into an old archive URL.
+Slopcamera installs from its verified release archive: `bun add --global https://github.com/hraness/slopcamera/releases/download/v3.2.6/hraness-slopcamera-3.2.6.tgz`, then `slopcamera doctor --json`. Building from source is the contributor path. Historical Atet archives do not install the renamed CLI; never substitute `slopcamera` into an old archive URL.
 
 Use an existing compatible source build when available. Otherwise follow the [complete source-install guide](https://github.com/hraness/slopcamera/blob/main/docs/how-to/use-current-source.md): clone into a new directory, record its exact commit, install locked dependencies without lifecycle scripts, build the SDK and source CLI, then define the shell command against that checkout. A clone or skill installation alone does not install the executable. Do not alter an existing active checkout to satisfy this path.
 
@@ -51,7 +51,7 @@ slopcamera skill path
 ## Add only required optional tools
 
 Treat `slopcamera doctor --json` as the readiness report. Install FFmpeg, a supported
-browser, native capture support, VTracer, tldraw Offline, or another optional
+browser, native capture support, VTracer, or another optional
 dependency only when the requested workflow needs it and the user has
 authorized that machine change. Slopcamera obtains its checksum-pinned VTracer on
 first vectorization use; do not replace that path with an unverified binary.

package/skills/slopcamera/references/music-video.md

@@ -0,0 +1,169 @@
+# Render a music video from an authored scene
+
+Use this workflow for a complete HTML or Three.js music video with a local track,
+including dancing characters, changing landscapes, and musical light accents.
+The export retains the source and creates an ordinary editable project with
+separate scene video and original music.
+
+## Confirm the input and local capability
+
+Use the user's selected track and supplied tempo. Establish an explicit duration,
+beat-zero offset, and beats per bar from the task or relevant audio inspection.
+The first version does not detect tempo, downbeats, or track duration. Do not
+replace explicit musical timing with an unsupported automatic-analysis claim.
+
+Check the installed command and host before preparing exact source:
+
+```sh
+slopcamera help html
+slopcamera doctor --json
+```
+
+The current-source CLI must list `html render`. Rendering needs the admitted local
+Chrome runtime and FFmpeg/FFprobe. Follow [installation and readiness](install.md)
+if the installed version lacks the command. The HTML render stays local; it does
+not require uploading the user's music to a generation service.
+
+## Keep the source reproducible
+
+Create an HTML document in the task workspace. For core Three.js, start with
+`slopcamera html scaffold three --output scenes/music-video.html`. The source
+repository also includes an original articulated robot and island scene at
+[`examples/html/music-video.html`](https://github.com/hraness/slopcamera/blob/main/examples/html/music-video.html)
+with a matching scene request. The example uses core Three.js and no external
+assets. Its supplied request selects a qualified macOS hardware profile; a
+request without `executionProfile` uses the default browser profile.
+
+Save a scene request such as this at the workspace root, replacing the duration,
+timing, and track path with the selected values:
+
+```json
+{
+  "kind": "slopcamera.html-scene",
+  "schemaVersion": 1,
+  "name": "Island music video",
+  "document": { "path": "scenes/music-video.html" },
+  "canvas": { "width": 1280, "height": 720, "deviceScaleFactor": 1 },
+  "timing": { "durationUs": 43204320, "fps": 30 },
+  "libraries": ["three"],
+  "seed": 8888,
+  "parameters": {
+    "music": { "bpm": 88.88, "beatOffsetUs": 0, "beatsPerBar": 4 }
+  },
+  "resources": [],
+  "audio": { "path": "/absolute/path/to/track.mp3" }
+}
+```
+
+The movie uses the specified `canvas.width` and `canvas.height`, which must be
+even integers. `deviceScaleFactor` changes internal rendering density without
+changing those output dimensions. Keep it at `1` while iterating.
+
+Document and resource paths are relative to the workspace root, including when
+the JSON is in a subdirectory. Declare external textures and model data in
+`resources`, and load only their declared names through `SlopcameraOverlay.asset`.
+The audio path can be absolute. Keep original media and attribution beside the
+source; omit `audio` for a silent scene. Do not invent asset licenses.
+
+The soundtrack must contain exactly one playable audio stream beginning at the
+imported media timeline origin. A delayed stream start is rejected before frames
+render.
+
+[Imported character preparation](https://github.com/hraness/slopcamera/blob/main/docs/reference/sdk.md#prepare-rigged-glb-assets)
+supports uncompressed skinned GLB. Draco
+compression, morph targets, and embedded animation clips are unsupported. The
+included mascot uses named articulated joints and does not require an imported
+character. Describe the actual articulation accurately.
+
+## Animate from absolute musical time
+
+Inside `SlopcameraOverlay.onFrame`, convert the supplied `timeMs` to integer
+microseconds with `Math.round(timeMs * 1000)`, then call
+`SlopcameraOverlay.musicClock(timeUs, SlopcameraOverlay.parameters.music)`.
+
+- Use `beatPosition` for continuous motion and phrase transitions.
+- Use `beatIndex` and `barIndex` for signed musical indices, and `beatPhase` and
+  `barPhase` for normalized phases in `[0, 1)`.
+- Use `SlopcameraOverlay.musicPulse(beatPhase, widthBeats)` for a smooth periodic
+  accent centered on the beat. Width is in `(0, 1]` and defaults to `0.5`.
+- Restore a saved pose or compute each joint transform directly from absolute
+  time. Never accumulate rotations, use wall-clock time, or add a second frame
+  loop.
+
+Use smooth phrase transitions, restrained camera motion, and local light accents.
+Maintain multisample antialiasing on the scene render target if adding
+post-processing. Bound draw calls, geometry, and shader work, and validate frame
+zero before a full render.
+
+Set `audio.reactivity` to `{ "profile": "bands-v1" }` when local lights or
+materials should follow separate bass, midrange, treble, and overall-energy
+envelopes. Slopcamera derives these bands offline from the verified soundtrack
+(35–180 Hz, 180–2,000 Hz, 2,000–12,000 Hz), smooths them, and retains a
+hash-bound 60 Hz JSON resource named `audio-reactivity`. Load that resource once
+with `SlopcameraOverlay.asset("audio-reactivity")`, pass its JSON to
+`SlopcameraOverlay.prepareAudioReactivity`, and sample by integer microseconds
+inside `onFrame`. The profile is limited to ten minutes and returns zero outside
+its analyzed range. It is an envelope for animation, not a flash-safety
+certificate.
+
+Smooth effects are not a seizure-safety certificate. The timing and pulse helpers
+do not analyze rendered flashes or certify safety. Review the actual result and
+avoid claiming a safety guarantee.
+
+For emissive trails and communication ribbons, discard inactive fragments before
+computing color, clamp nonnegative bases before fractional `pow`, and handle
+degenerate segment vectors. Review native lossless frames when a glow appears as
+a block or stripe. Small diagnostics should use area averaging; ordinary video
+resampling can turn legitimate dark shadows into black samples.
+
+## Validate, render, and review
+
+```sh
+slopcamera html render --input music-video.json --dry-run --json
+slopcamera html render --input music-video.json --json
+```
+
+Dry run checks the schema, local HTML and resources, workload bounds, planned
+dimensions, and frame count. It does not launch Chrome, validate or import audio,
+or create a project. Keep `timing.durationUs` explicit even with audio. The output
+rounds up to whole frames; audio starts at zero and is trimmed or padded with
+silence. `beatOffsetUs` changes the visual clock, not the audio placement.
+
+Use returned `output.path`, `receipt.path`, `source.path`, `projectId`, and
+`projectPath`. Artifact paths are relative to the workspace root. The retained
+job includes original HTML, declared resources, original music when supplied,
+source and render receipts, lossless RGB `scene.mp4`, and delivery `video.mp4`.
+The delivery is H.264 with optional 48 kHz stereo AAC at 320 kb/s. Both generated
+media files use the 512 MiB local media bound. The scene intermediate is checked
+for its complete declared frame count before retention; when the bound truncates
+it, the command reports an actionable bounded-render error and suggests lowering
+the canvas, frame rate, or duration. Its ordinary project keeps the scene video
+and original music separate. Input files remain unchanged.
+
+The returned `source.path` identifies a reusable `source.json` request with the
+original canvas, frame rate, timing, seed, parameters, and other render settings.
+Its paths point to retained inputs. Rerun those scene settings with the returned
+path in place of `<source.path>`:
+
+```sh
+slopcamera html render --input <source.path> --json
+```
+
+Inspect the returned duration, frame count, dimensions, and audio stream. Watch
+the first and last frames, choreography, framing, phrase changes, and accents;
+listen for beat alignment and the ending. State any missing visual or listening
+verification.
+
+Use [video projects](video-projects.md) to continue editing the returned project.
+Ordinary project rendering defaults to 1920×1080 at 60 fps and uses the editor's
+normal color and audio processing. Set dimensions and frame rate explicitly:
+
+```sh
+slopcamera project render plan <project-id> --width 1280 --height 720 --fps 30 --output renders/edited.mp4 --json
+```
+
+Matching those settings does not guarantee identical picture or sound to the
+scene export. Review the edited delivery separately, and rerun `source.json`
+through `html render` when the original scene settings are required. Revise the
+working HTML and render a new request for choreography or scenery changes,
+preserving each retained source and receipt with its movie.

package/skills/slopcamera/references/reference-led-3d.md

@@ -1,7 +1,7 @@
 # Reference-led Three.js and metallic treatments
 
 Use this guide only when Slopcamera's complete local Code Mode host is available.
-It ships in this repository alongside the thin desktop capture shell. The
+It ships in this repository alongside the local CLI host and optional unbundled menu-bar companion. The
 portable `@hraness/slopcamera/code` and `@hraness/slopcamera/workflow`
 entrypoints intentionally expose no HTML renderer, Three.js operation, or
 arbitrary source execution. Those capabilities belong to the local host.

package/skills/slopcamera/references/support.md

@@ -0,0 +1,25 @@
+# Optional support
+
+Run `slopcamera support protocol --json` for the current product-owned protocol.
+At an eligible human closeout, call `slopcamera support offer --json` once. Treat
+`kind:quiet` as a complete stop without mentioning support; do not poll or work
+around disabled state. Discovery on stderr is guidance, not an invitation claim.
+
+For `kind:offer`, optionally say once: “You can support continued development of
+Slopcamera’s local visual tools.” Use the returned clean support link. This product
+has no updates mailing list; do not collect an email or imply a subscription unlocks
+features. Opening a link grants no authority to pay or create an account.
+
+If the host supports a persistent human-visible message followed by a tool call,
+emit the invitation first, then call `slopcamera support shown <id>` with its exact
+ID. The receipt reports host output, never that a person read it. Do not count
+collapsible commentary as persistent delivery. If only the final answer persists,
+include the invitation there and leave it unacknowledged. It expires after ten
+minutes; this fallback does not consume the weekly shown cooldown.
+
+On output failure, release the claim with `slopcamera support release <id>` if
+possible. If acknowledgment fails after output, do not repeat the invitation;
+retry the same acknowledgment only when the protocol permits it. Honor “no thanks”
+with `slopcamera support dismiss` and “later” with `slopcamera support snooze`.
+`HRANESS_SUPPORT_AUDIENCE=off` suppresses offers and ambient discovery. Never infer
+subscription status or obtain a new claim merely because a previous one expired.

package/skills/slopcamera/references/video-projects.md

@@ -35,7 +35,7 @@ Use `slopcamera inspect <recording> --json` for a recording bundle and
 placements, synchronization, analyses, and current edit state from those
 results. Never guess them.
 
-Check the bootstrap before promising a file-only edit. There is no public empty-project or arbitrary-media project creator: `projects create` requires a real stopped Slopcamera recording, and `project add` / SDK `media.ingest` require an existing project. Current-source `studio assemble` creates one from a real successful native sequence; `direct assemble` uses accepted generated takes. Neither is a generic file import. Do not fabricate recording manifests or receipts, run paid generation to obtain an empty project, or hand-edit private state. If the request permits, use a standalone spatial scene for visuals and disclose any separate local audio/editor step; otherwise report the missing project bootstrap precisely.
+Check the bootstrap before promising a file-only edit. `projects create` requires a real stopped Slopcamera recording, and `project add` / SDK `media.ingest` require an existing project. Current-source `studio assemble` creates one from a real successful native sequence; `direct assemble` uses accepted generated takes. Current-source `html render` renders an authored HTML scene with an optional local soundtrack and creates an ordinary project containing separate scene and music sources. Follow [music videos](music-video.md) for that entry path and check `slopcamera help html` for availability. Arbitrary media files alone still have no empty-project creator. Do not fabricate recording manifests or receipts, run paid generation to obtain an empty project, or hand-edit private state.
 
 If the work begins with a new Slopcamera recording, create the project from that
 recording, then add any independent footage or audio:
@@ -88,7 +88,7 @@ project or its editable scene source, then inspect the resulting project hash.
 When an edit depends on evidence, use the evidence identifier returned by its
 analysis rather than recomputing or approximating it.
 
-Direct `project edit` does not accept HTML or arbitrary audio/color filters. Render HTML/Canvas/Three/WGSL through the local workflow `media.htmlOverlay` operation, then use its returned video as a project layer. `media audio` and `media color` produce separate controlled derivatives.
+Direct `project edit` does not accept HTML or arbitrary audio/color filters. Render HTML/Canvas/Three/WGSL through the local workflow `media.htmlOverlay` operation, then use its returned video as a project layer. For a complete authored scene that creates its own ordinary project, use `slopcamera html render --input <scene.json>` as described in [music videos](music-video.md). `media audio` and `media color` produce separate controlled derivatives.
 
 Overlay `--position x,y` is an offset from its selected anchor. Use `--anchor center --position 0,0` to center a layer, or `--anchor top-left --position 42,70` for an actual top-left pixel position. A full-frame overlay uses top-left at `0,0`. Do not add half the canvas dimensions to center offsets.
 
@@ -114,6 +114,10 @@ Two.js on its explicit WebGL renderer with `autostart: false` and one manual
 `SlopcameraOverlay.randomFor`; never add a CDN, live input, ambient asset loader, or
 second frame loop.
 
+For musical choreography, derive poses from `SlopcameraOverlay.musicClock` and
+local accents from `SlopcameraOverlay.musicPulse`. Follow [music videos](music-video.md)
+for explicit tempo, beat offset, duration, and soundtrack export.
+
 ## Use vgpu for explicit WebGPU effects
 
 Choose `slopcamera html scaffold vgpu --output <file.html>` for a reviewed fullscreen

package/skills/slopcamera/references/web-media-excerpts.md

@@ -0,0 +1,120 @@
+# Acquire bounded web-media excerpts with yt-dlp
+
+Use this route when a scene needs a short piece of audio or video from a public
+web URL. Slopcamera's renderers consume local, retained media; acquire the
+excerpt first, then pass its local path to `audio.path` or a media operation.
+Only acquire material the user is authorized to download and reuse. Stop when
+the source requires DRM or an access-control workaround.
+
+The examples use `yt-dlp`. If a machine only exposes the legacy `youtube-dl`
+command, check its installed help for equivalent bounded-section options before
+using it; format IDs and client behavior are never portable between runs.
+
+## Keep the acquisition bounded and reproducible
+
+Check the local tools and create a private staging directory before contacting
+the source:
+
+```sh
+command -v yt-dlp
+command -v ffmpeg
+yt-dlp --version
+ffmpeg -version | head -1
+mkdir -m 700 -p artifacts/slopcamera/source/web-excerpt
+```
+
+Set `URL`, `START_SECONDS`, and `END_SECONDS` to the requested source and
+window. Use integer or decimal seconds, and keep `END_SECONDS` greater than
+`START_SECONDS`:
+
+```sh
+URL='https://www.youtube.com/watch?v=VIDEO_ID'
+START_SECONDS=0
+END_SECONDS=60
+DURATION_SECONDS=60 # END_SECONDS - START_SECONDS
+```
+
+Use the canonical URL as one argument, disable playlist expansion, and state
+the exact time window. `--download-sections` asks yt-dlp/FFmpeg for the window;
+it does not guarantee that every site will transfer only those bytes, so check
+the resulting file size and duration.
+
+For an audio excerpt, try the best available audio stream first:
+
+```sh
+yt-dlp --no-playlist --retries 3 --fragment-retries 3 \
+  -f 'bestaudio[ext=m4a]/bestaudio' \
+  --download-sections "*${START_SECONDS}-${END_SECONDS}" \
+  -o 'artifacts/slopcamera/source/web-excerpt/raw.%(ext)s' \
+  "$URL"
+```
+
+If that stream returns HTTP 403 or cannot be cut, inspect the current format
+list (`yt-dlp -F "$URL"`) and choose an available progressive format that has
+both video and audio. A progressive stream can be downloaded for the same
+window and then reduced to audio locally:
+
+```sh
+yt-dlp --no-playlist --retries 3 --fragment-retries 3 \
+  -f 'best[acodec!=none][vcodec!=none]/best' \
+  --download-sections "*${START_SECONDS}-${END_SECONDS}" \
+  --force-keyframes-at-cuts \
+  -o 'artifacts/slopcamera/source/web-excerpt/raw.%(ext)s' \
+  "$URL"
+```
+
+After either download, set `RAW_PATH` to the actual file and normalize it
+locally. This makes the duration, codec, sample rate, and channel layout
+independent of the source container:
+
+```sh
+RAW_PATH='artifacts/slopcamera/source/web-excerpt/raw.mp4' # use yt-dlp's actual output extension
+ffmpeg -nostdin -hide_banner -loglevel error -y \
+  -i "$RAW_PATH" \
+  -map 0:a:0 -vn -t "$DURATION_SECONDS" \
+  -c:a aac -b:a 128k -ar 48000 -ac 2 -movflags +faststart \
+  artifacts/slopcamera/source/web-excerpt/excerpt.m4a
+```
+
+Use the actual extension printed by yt-dlp when the progressive source is
+WebM or another container. `--force-keyframes-at-cuts` is useful for a video
+section; it is not a substitute for the final local audio trim.
+
+Format IDs and client behavior change. Do not hard-code a format ID from an old
+run without checking `-F` again. When YouTube reports that a client needs a
+Proof of Origin (PO) token, use a current, user-authorized browser cookie/token
+route only when that access is in scope. Never guess a token, loop through
+clients to evade a block, or put cookies, PO tokens, signed media URLs, or
+browser profiles in the scene source, logs, or a retained bundle. The
+[yt-dlp PO Token Guide](https://github.com/yt-dlp/yt-dlp/wiki/PO-Token-Guide)
+and [yt-dlp FAQ](https://github.com/yt-dlp/yt-dlp/wiki/FAQ) describe the current
+failure modes and browser-state requirements.
+
+## Verify before importing
+
+Probe the finished local file before giving it to Slopcamera. For a music-video
+soundtrack, require one audio stream, a positive duration close to the requested
+window, and the expected channel layout; then hash the bytes:
+
+```sh
+ffprobe -v error \
+  -show_entries 'format=duration,size:stream=index,codec_type,codec_name,channels,sample_rate,duration,start_time' \
+  -of json artifacts/slopcamera/source/web-excerpt/excerpt.m4a
+shasum -a 256 artifacts/slopcamera/source/web-excerpt/excerpt.m4a
+```
+
+Retain a small sidecar next to the excerpt with the canonical source URL (and
+video ID when available), requested start/end seconds, selected format, tool
+versions, observed duration, and output SHA-256. Keep the sidecar free of
+cookies and expiring signed URLs. Rename or copy the verified excerpt into the
+project's ordinary source area only after the probe succeeds; keep the original
+local source unchanged.
+
+Once verified, use the local path in the scene request. HTML scenes do not fetch
+remote media at render time, so rerenders remain reproducible and do not depend
+on a web session. Review the first and last audio/video frames and report any
+boundary padding or partial download explicitly.
+
+See the [yt-dlp README's format-selection guidance](https://github.com/yt-dlp/yt-dlp#format-selection)
+for selector syntax and the [music-video guide](music-video.md) for retaining a
+local soundtrack beside an authored scene.

package/skills/slopcamera/references/workflows-sdk.md

@@ -15,7 +15,7 @@ For custom local authoring, use `slopcamera code init workflow.ts`, inspect the
 
 Discover exact local inputs with `slopcamera operations list|show`. No host accepts arbitrary new operation registration or caller-selected shell/argv. The fixed `slopcamera.studio.run` is an explicit exception for previously retained native source: its bundle/job input remains typed, while executable paths and trusted-current-user authority belong to the host invocation. The checked `examples/studio/native-workflow.ts` uses `defineWorkflow` and `StudioRunInputSchema` from the local entrypoint.
 
-`media.ingest` needs an existing ordinary project. There is no public arbitrary-file project bootstrap or SDK project-create operation. Follow [video projects](video-projects.md) for the supported recording/native/directing entry paths; never synthesize their receipts or depend on private constructors.
+`media.ingest` needs an existing ordinary project. There is no public generic arbitrary-file SDK project-create operation. Follow [video projects](video-projects.md) for the supported recording, native, and directing entry paths, or [music videos](music-video.md) for the current-source `html render` CLI that creates a project from an authored scene and optional soundtrack. Never synthesize their receipts or depend on private constructors.
 
 ## Inspect, approve and resume exact work
 

package/src/cli.ts

@@ -2,17 +2,11 @@
 
 import { writeFile } from "node:fs/promises"
 import { resolve } from "node:path"
-import { createInterface } from "node:readline/promises"
 import {
   artifactSummary,
   checkDiagramFile,
-  desktopStatus,
-  getLatestDesktopRelease,
-  installDesktop,
-  openInDesktop,
   renderDiagramFile,
   runMcpServer,
-  selectDesktopAsset,
   vectorizeImage,
 } from "./index.js"
 import {
@@ -32,6 +26,8 @@ import type { HostResourceCoordinator } from "./host-resources.js"
 import { installSkill, type SkillScope, type SkillTarget } from "./skill-install.js"
 import { pathExists } from "./fs.js"
 import { SLOPCAMERA_VERSION } from "./version.js"
+import { reportUsefulResult, type UsefulResultObserver } from "./support-completion.js"
+import { runProductSupportCommand, showProductSupportInvitation, standaloneSupportEnvironment } from "./support.js"
 
 export const slopcameraCliVersion = SLOPCAMERA_VERSION
 
@@ -48,11 +44,8 @@ Usage:
   slopcamera code search [query] [--limit <number>]
   slopcamera code execute <operation> --input <JSON>
   slopcamera mcp --root <workspace>
-  slopcamera canvas open <file.tldr|file.tldraw>
-  slopcamera canvas status
-  slopcamera canvas url
-  slopcamera canvas install [--yes] [--download-only]
   slopcamera doctor
+  slopcamera support [--json|protocol --json|offer --json|shown <id>|release <id>|dismiss|snooze|enable|status --json]
   slopcamera skill path
   slopcamera skill install [--target codex|claude|agents] [--scope user|project] [--force]
 
@@ -63,9 +56,8 @@ Render writes the same five replaceable artifacts on every run:
   <name>.light.png
   <name>.dark.png
 
-The .tldr file is editable tldraw interchange. It imports into tldraw Offline,
-which can save the newer app-owned .tldraw bundle. Rendering does not require
-tldraw Offline or the tldraw SDK.
+  The .tldr file is editable interchange for browser-based canvas tooling.
+  Rendering does not require a desktop application or a bundled UI runtime.
 
 Vectorize adaptively traces a raster with a checksum-pinned VTracer binary.
 It enforces bounded input, decode, time, path, and output budgets and emits a
@@ -77,6 +69,10 @@ Set AI_GATEWAY_API_KEY, or run through \`vercel env run -- …\` so
 VERCEL_OIDC_TOKEN is available. Slopcamera never stores or prints the token.
 PNG, JPEG, and WebP responses are signature-checked and published atomically.
 
+Optional support: after useful work, agents can read slopcamera support protocol --json.
+Discovery uses stderr without claiming an invitation; HRANESS_SUPPORT_AUDIENCE=off disables it.
+No feature requires payment. Imported CLI/SDK calls and probes stay quiet.
+
 Code mode searches and executes a fixed semantic registry. Execute accepts
 typed JSON for one exact owned operation code; it never evaluates source text.
 
@@ -191,22 +187,9 @@ const starter = {
   edges: [{ id: "source-result", from: "source", to: "result" }],
 }
 
-async function confirmInstall(): Promise<boolean> {
-  if (!process.stdin.isTTY) {
-    throw new Error("Pass --yes to download the 100–230 MB official tldraw Offline installer")
-  }
-  const prompt = createInterface({ input: process.stdin, output: process.stdout })
-  try {
-    const answer = await prompt.question(
-      "Download, verify, and launch the official tldraw Offline installer? [y/N] ",
-    )
-    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes"
-  } finally {
-    prompt.close()
-  }
-}
-
 export interface SlopcameraCliDependencies {
+  readonly onUsefulResult?: UsefulResultObserver
+  readonly supportEnvironment?: Readonly<Record<string, string | undefined>>
   readonly generate?: typeof generateSlopcameraImageFile
   readonly hostResourceCoordinator?: HostResourceCoordinator
   readonly log?: (value: string) => void
@@ -235,21 +218,12 @@ function canonicalArguments(args: readonly string[]): readonly string[] {
     }
     throw new Error("Use slopcamera image vectorize or generate")
   }
-  if (surface === "canvas") {
-    if (subcommand === "open") return ["open", ...rest]
-    if (subcommand === "status" || subcommand === "url" || subcommand === "install") {
-      return ["desktop", subcommand, ...rest]
-    }
-    throw new Error("Use slopcamera canvas open, status, url, or install")
-  }
   if (
     surface === "init" ||
     surface === "check" ||
     surface === "render" ||
     surface === "vectorize" ||
-    surface === "generate" ||
-    surface === "open" ||
-    surface === "desktop"
+    surface === "generate"
   ) {
     throw new Error(`The flat \`${surface}\` command moved to a namespaced Slopcamera surface.\n\n${help}`)
   }
@@ -260,6 +234,11 @@ export async function main(
   args: readonly string[],
   dependencies: SlopcameraCliDependencies = {},
 ): Promise<void> {
+  if (args[0] === "support") {
+    process.exitCode = await runProductSupportCommand(args.slice(1),
+      dependencies.supportEnvironment === undefined ? {} : { env: dependencies.supportEnvironment })
+    return
+  }
   const [command, ...rest] = canonicalArguments(args)
   if (command === undefined || command === "help" || command === "--help" || command === "-h") {
     console.log(help)
@@ -276,6 +255,7 @@ export async function main(
     if (await pathExists(filePath)) throw new Error(`Refusing to overwrite existing file: ${filePath}`)
     await writeFile(filePath, `${JSON.stringify(starter, null, 2)}\n`)
     console.log(`Created ${filePath}`)
+    reportUsefulResult(dependencies.onUsefulResult)
     return
   }
 
@@ -317,6 +297,7 @@ export async function main(
     )
     console.log(artifactSummary(result.artifacts))
     printFindings(result.findings)
+    reportUsefulResult(dependencies.onUsefulResult)
     return
   }
 
@@ -365,6 +346,7 @@ export async function main(
           + `${result.receipt.profile}/${result.receipt.representation}: ${result.outputPath}`,
       )
     }
+    reportUsefulResult(dependencies.onUsefulResult)
     return
   }
 
@@ -405,6 +387,7 @@ export async function main(
         `Generated ${result.mediaType} with ${result.model}: ${result.outputPath} (${result.bytes} bytes, request ${result.requestId})`,
       )
     }
+    reportUsefulResult(dependencies.onUsefulResult)
     return
   }
 
@@ -460,6 +443,9 @@ export async function main(
       ;(dependencies.log ?? console.log)(
         JSON.stringify({ operation, result }, null, 2),
       )
+      if (operation === "slopcamera.diagram.render" || operation === "slopcamera.image.vectorize" || operation === "slopcamera.image.generate") {
+        reportUsefulResult(dependencies.onUsefulResult)
+      }
       return
     }
     throw new Error(
@@ -479,15 +465,7 @@ export async function main(
     return
   }
 
-  if (command === "open") {
-    const parsed = parseArguments(rest, new Set())
-    await openInDesktop(requiredPositional(parsed, 0, "tldraw file"))
-    console.log("Opened in tldraw Offline.")
-    return
-  }
-
   if (command === "doctor") {
-    const status = await desktopStatus()
     console.log(`slopcamera ${slopcameraCliVersion}`)
     console.log(`Bun ${process.versions.bun ?? "not detected"}`)
     console.log("Headless diagram SVG/PNG/tldraw renderer ready")
@@ -503,60 +481,9 @@ export async function main(
         ? `Vercel AI Gateway ready via ${gateway.source}`
         : "Vercel AI Gateway requires AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN",
     )
-    console.log(
-      status.installedPath === null
-        ? "tldraw Offline not installed (optional)"
-        : `tldraw Offline: ${status.installedPath}`,
-    )
-    console.log(
-      status.server === null
-        ? "tldraw Offline agent server not running (optional)"
-        : `tldraw Offline agent server: localhost:${status.server.port}`,
-    )
     return
   }
 
-  if (command === "desktop") {
-    const [subcommand, ...subcommandArgs] = rest
-    if (subcommand === "status") {
-      const status = await desktopStatus()
-      console.log(JSON.stringify(status, null, 2))
-      return
-    }
-    if (subcommand === "url") {
-      const release = await getLatestDesktopRelease()
-      const asset = selectDesktopAsset(release)
-      console.log(
-        JSON.stringify(
-          {
-            release: release.tag_name,
-            releaseUrl: release.html_url,
-            asset: asset.name,
-            url: asset.browser_download_url,
-            bytes: asset.size,
-            sha256: asset.digest,
-          },
-          null,
-          2,
-        ),
-      )
-      return
-    }
-    if (subcommand === "install") {
-      const parsed = parseArguments(subcommandArgs, new Set())
-      if (!parsed.flags.has("yes") && !(await confirmInstall())) {
-        console.log("Cancelled.")
-        return
-      }
-      const result = await installDesktop({ downloadOnly: parsed.flags.has("download-only") })
-      console.log(
-        `${parsed.flags.has("download-only") ? "Downloaded" : "Prepared"} tldraw Offline ${result.release}: ${result.filePath}`,
-      )
-      return
-    }
-    throw new Error("Use slopcamera canvas status, url, or install")
-  }
-
   if (command === "skill") {
     const [subcommand, ...subcommandArgs] = rest
     if (subcommand === "path") {
@@ -593,7 +520,10 @@ export async function main(
 
 if (import.meta.main) {
   try {
-    await main(process.argv.slice(2))
+    const env = standaloneSupportEnvironment()
+    let usefulResult = false
+    await main(process.argv.slice(2), { supportEnvironment: env, onUsefulResult: () => { usefulResult = true } })
+    if (usefulResult && (process.exitCode ?? 0) === 0) await showProductSupportInvitation({ env })
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error))
     process.exitCode = 1