What's recorded, what isn't

The high-level commitment

The recording is the writing process inside the editor — nothing outside that window. Type, the keystroke is recorded. Switch tabs, the tab is invisible. Paste, and the recording sees a paste happened at a position — not the contents.

The recorder is a script on the editor element. Browser security blocks other tabs; we don't request clipboard or screen permissions.

What's recorded channels A & B

Two channels, both scoped to the editor.

Channel A — text events

• Keystrokes. Timestamp, cursor position, a coarse bucket: printable, Enter, Tab, Backspace, Delete. The literal character isn't stored — the document body has it.
• Pastes. Logged as {type:'paste', t, pos, len}. Content is never stored. A 200-character paste lands at position 1,420, length 200. We don't know what it said.
• Backspace bursts — runs of deletions coalesced with a count.
• Idle gaps — periods of no activity with duration.
• Focus / visibility flips — editor gaining or losing focus, tab backgrounding. We know the editor went inactive; not what you switched to.

Channel B — pointer events

• Cursor and pointer samples as coordinates inside the editor. 20 Hz active, 1 Hz idle.
• Selection ranges, click positions, scroll deltas, touch / swipe gestures.

Each event is one row of compact JSON. A 90-minute essay produces tens of kilobytes — small enough to ride inside an exported .red.md.

What's NOT recorded

None of these. If any shows up, that's a bug — report it.

• Your screen. No screen-capture API invoked.
• Camera or microphone. Never requested.
• Cursor movement outside the editor. The sampler only fires inside the editor's bounding box. Move to your dock, menu bar, another window — nothing emits.
• Clicks outside the editor. Other tabs, other apps, your desktop produce zero events.
• Typing in other windows. Alt-tab to your notes app — invisible. We know the editor lost focus, nothing else.
• Your clipboard. Paste events show when, where, how long — never what. The browser doesn't hand the clipboard to a page that didn't request the permission; we don't.
• Other browser tabs. Same-origin isolation blocks it.
• Files on disk. Only files you explicitly Import (.red.md or .docx).
• Browsing history. Search queries, sites visited — none.
• Geolocation. Not requested.
• Device fingerprints. No canvas fingerprinting, font enumeration, or user-agent indexing.
• Biometric data. Typing-rhythm aggregates are population statistics (section 7).

Provenance alone proves nothing

The recording isn't a transcript. Every event references a position; no event carries the character. A keystroke says "position 1,420, printable" — not "the letter A." A paste says "position 1,620, length 204" — never the text.

Provenance + the wrong document = positional gibberish. Paired with an unrelated essay, timestamps don't align with word boundaries, pastes land at wrong positions, idle gaps don't match sentence breaks.

The recording only means something paired with the document it was made against. Together they tell the story — typed for 90 seconds to position 432, pasted 204 characters, kept typing to 800, paused 12 seconds, deleted 18. Shape — rhythm, session length, paste sizes — is visible; content lives in the document.

When recording starts and stops

Recording begins when a recordable doc opens, runs while you're inside it, ends when the doc closes. No ambient mode.

Start

state.provenance.recording flips on when you open an assignment-tied document (or toggle it on for a personal doc). The bottom-left RECORDING badge is the visible signal.

Stop

Doc close, logout, navigation away. Badge disappears.

Pause / blur

Switching tabs logs focus: false, drops the sampler to 1 Hz, pauses capture. Returning resumes it. The gap stays as a real gap, not interpolated.

Recording reflects time in the editor, not elapsed time. Walk away for two hours — that's two hours of nothing.

Where the recording lives localStorage + Convex File Storage

Two phases: browser while composing, signed envelope on the server at submit.

While composing — browser only

The event stream buffers in memory and flushes to localStorage under red-stet.provenance.v1.<slug> every 30 seconds and on page-close. Nothing leaves the device. Close without saving and the buffer stays.

At submit / autosave — signed envelope on the server

Buffered events wrap in a signed envelope and upload to Convex File Storage as one blob. The signature attests to the whole envelope; tampering breaks the chain. Retrievable by the doc owner, the assignment teacher, and anyone holding a shared verifier link.

Voice-profile mirror — aggregate only

An aggregate of your typing rhythm sits in authorProfiles so a teacher grading on another device sees your baseline:

• Eight inter-keystroke timing buckets (histogram, not individual times)
• Median and 95th-percentile pause length
• Typo rate, scroll-up fraction, selection-read rate
• Up to 200 contributing document slugs and chain-head hashes (no body, no content)

Not in the profile: individual keystroke times, paste events, cursor coordinates, document text. Statistics about how you write — not what you wrote.

The quiet layer — rhythm fingerprints

Red Stet computes fingerprints from the document body — vocabulary spread, sentence length, AI-tell density. Derived from prose, not a separate surveillance channel.

Two essays from the same student with wildly different fingerprints raise a question. They don't answer it.

What the fingerprint isn't

Not a unique identifier. Students overlap on any single metric. Population statistic — can't unlock a phone, can't be queried against an unknown-writer database, can't identify you outside Red Stet.

Not a verdict. The number doesn't say "this is AI" or "this is plagiarized." It's a baseline.

Who can see your recording

Small audience by default.

You — always

Open the Review panel from the editor and scrub through any time.

Your teacher — for submissions

After submit, the recording is readable by the class owner. The Convex read function checks classroom ownership; teachers in your other classes can't read it.

Classroom staff with grading rights

A co-teacher or TA with grading enabled has the same access as the owning teacher for that class. Audit-logged.

Nobody else

Not other students. Not other teachers. Not administrators unless enrolled as classroom staff. Not Red Stet staff in routine operations. Not third-party AI-detection vendors.

Where the teacher's review session resumes users.preferences.replayPositions

The teacher's replay state, not the student's recording. The recording stays what it was at submit.

When a teacher scrubs to a moment and closes the review, opening the same submission on another device picks up at the same timestamp. Per-submission position on the teacher's user row at users.preferences.replayPositions, saved as they scrub (throttled).

Teacher-side only. Students never see where their teacher is — no presence indicator, no read receipt.

When the position resets

Two cases: Restart from beginning, or the recording is purged via class retention (orphan cleaned up on next read). Tab close, device switch, session end don't reset.

Why this exists

A 90-minute recording across two sittings used to mean re-scrubbing. Position memory removes the friction.

Self-checks are logged

The Run self-check button next to Submit shows the same provenance flags your teacher would see — large-paste, tab-paste, off-page-paste, style-shift, whatever surfaces.

Use it to verify your work isn't tripping a flag for an innocent reason — a long quote, a citation paste, a fluent paragraph diverging from your baseline. See what the teacher sees, decide whether to clarify in a comment.

Every self-check is logged on your submission with a timestamp, flag categories, and a content hash. The teacher's grading view shows the history alongside the rubric.

What the teacher sees:

• How many times you ran self-check, and when.
• Categories surfaced at each check.
• A category that appeared in an earlier check and disappeared later gets a red border — the disappearance is the signal.

Retention and deletion — voice profile as a lifetime asset

The model is lifetime by default with friction-wipe.

Why lifetime

The voice profile and accumulating recordings are the long-term value:

• Prove authorship years later. A high-school piece re-verifies for college admissions, job applications, writing grants — anywhere a third party asks "did you actually write this?"
• Portable identity-as-writer. The voice profile is the trace of how you write — phrase choices, sentence rhythm, idle cadences. Over time it becomes a portrait.

Default: recordings + voice profile live indefinitely, tied to your account.

Friction-wipe — the disaster button

Settings → Privacy → Wipe everything. Deliberately gated:

• Cost disclosure — "you will lose your voice profile, your authorship-verification leverage, and your portfolio. This cannot be undone."
• Typed confirmation — type "wipe my Red Stet history" before the cooldown starts.
• 7-day cooldown. Cancellable from any device. Blocks impulse and account-takeover deletes.
• Per-account scope. Deletes recordings + voice profile + author profile. Submitted assignments stay on the class as the teacher's record; recordings are stripped.

See Friction-wipe in the retention doc for the per-table inventory.

Close account, keep record

The less-destructive sibling at Settings → Privacy → Close account, keep record. Severs sign-in identity, keeps recordings as anonymous-but-attributed entries. See Close account, keep record.

Classroom deletion

Deleting a classroom cascades enrollments, assignments, group memberships. Your personal documents and recordings don't cascade — those belong to you.

How this is different from AI detection

AI detectors read the final text and guess whether a human wrote it — classifiers on the output, after the fact, with no access to how it was made. They produce false positives that harm real student writers and get gamed by light paraphrasing.

Red Stet runs the other way. We record the process. The recording is the evidence. No classifier to fool — there's a literal timeline of what happened in the editor.

Consequences:

• Red Stet is a tool the student carries, not a verdict imposed. The recording is the student's proof first, the teacher's evidence second.
• Third-party AI-likelihood scores aren't Red Stet outputs. We don't generate them.
• The teacher does the judgment. The recording shows organic drafting or it doesn't.

The one-line summary

Red Stet records the writing process inside the editor — keystroke positions, paste positions and lengths, idle gaps, focus changes. It does NOT record what you typed (the document has that), your screen, your camera, your other apps, or anything outside the editor. The recording lives indefinitely as part of your lifetime authorship record, with a friction-wipe escape hatch.

Students: the recording is on your side. The teacher uses it to verify you did your own work; you use it to prove you did against any tool or accusation. The voice profile accumulates into evidence — useful in college admissions, job applications, anywhere authorship needs proving.

Teachers: the small audience and structural scope make Red Stet defensible to an IT director on a Tuesday afternoon. The code can't reach the places where invasive things would happen.

Administrators and parents: DPA requests, account anonymization, breach notifications — [email protected]. Source of truth: docs/PRIVACY.md.

Related

→ Reading the provenance recording — the scrubber, spotting a paste, when to dig deeper.

→ Talking to students about the recording — a day-one script.

→ Co-teachers & TAs — who gets recording access when you invite grading help.

→ Back to the help library.

Privacy question this doc missed? Email feedback.