Recall Quest

Tracks

1. 01🗄️The Archive

   0/4 lessons

   What Recall is, where it sits in the family, and why it exists

   Before any architecture, the orientation. Recall is a video-memory engine — not a transcription tool, not a search box on a folder, not a cloud you upload your life to. This track frames the memory problem it solves, places Recall as the archive sibling in the cwkPippa engine family, answers the first question anyone asks a self-built tool — why not just rent one? — and draws the sharp line between rebuilding an old project and remaking it from current ground truth.

   Lesson list (4)

   • 01
     What Recall Is~11 min · identity, overview, search, engine
   • 02
     The Engine Family~10 min · family, api-first, no-own-brain, architecture
   • 03
     Build vs Rent~11 min · build-vs-rent, ownership, privacy, scope
   • 04
     Remake, Not Remaster~12 min · remake, legacy, parity-oracle, migration

   ✓Quiz · 4 questions→

2. 02🖥️Two Hosts, One Truth

   0/4 lessons

   Control plane, stateless executor, and the rule that binds them

   Recall runs across two always-on machines and a dev laptop, and the split is deliberate. One host is the control plane and the single source of truth; the other is a stateless executor that does the heavy, slow, expensive work and owns nothing. This track teaches the distributed-systems spine: why you separate the plane that decides from the plane that executes, the one rule that keeps them honest — a computation isn't complete until the control plane durably accepts it — why a web request must never own hours of work, and why code and state travel on different rails.

   Lesson list (4)

   • 01
     Control Plane vs Executor~11 min · control-plane, executor, distributed-systems, topology
   • 02
     Not Complete Until Accepted~12 min · completion, durability, idempotency, core-rule
   • 03
     Requests Don't Own Long Work~10 min · requests, workers, async, durability
   • 04
     Code vs State~10 min · code, state, deployment, boundary

   ✓Quiz · 4 questions→

3. 03🧾Evidence Before Truth

   0/5 lessons

   Raw output is a permanent record; truth is a version layered on top

   The heart of Recall's data model, and its most transferable idea: never confuse what a machine returned with what is true. The raw speech-to-text output is immutable evidence — a permanent record of exactly what a specific model said for specific bytes. The user-facing transcript is a versioned release derived from that evidence, correctable without ever mutating the original. This track separates the run from the release, shows why corrections branch instead of overwrite, how a content hash makes every downstream artifact's staleness detectable, and why an automated quality score is advisory — never proof.

   Lesson list (5)

   • 01
     Raw Is Immutable~11 min · evidence, immutability, audit, append-only
   • 02
     Run vs Release~11 min · run, release, versioning, model
   • 03
     Corrections Branch~11 min · corrections, branch, content-hash, copy-on-write
   • 04
     Content Hash Detects Stale~11 min · content-hash, content-addressing, lineage, staleness
   • 05
     Quality Is Advisory~10 min · quality, advisory, not-proof, gate

   ✓Quiz · 4 questions→

4. 04💳Pay Once

   0/5 lessons

   Reserve before you spend, pay once per identity, never auto-retry a maybe-billed call

   Every transcription call costs real money, and a naive retry loop over a flaky network can quietly pay for the same audio five times. This track is the money discipline that prevents it: a reservation ledger the request must cross before any paid call, a content-addressed identity so the same audio is bought at most once, an explicit 'ambiguous' state for the terrifying case where the provider may have charged you but you have no result, and the deliberate refusal to automatically retry a call that might already be billed. It ends with the outbox — how the executor protects a paid response it already holds.

   Lesson list (5)

   • 01
     Reservation Before POST~11 min · reservation, ledger, write-ahead, before-spend
   • 02
     Content-Addressed Identity~11 min · content-addressing, identity, at-most-once, hashing
   • 03
     The Ambiguous State~12 min · ambiguous, state-machine, billing, uncertainty
   • 04
     No Automatic Retry~11 min · retry, billing-ambiguity, idempotency, intentional
   • 05
     The Outbox~10 min · outbox, store-and-forward, durability, replay

   ✓Quiz · 4 questions→

5. 05🧬Never Trust 'Already Done'

   0/4 lessons

   No single flag, a ladder of identities, and what --force really means

   A single 'done' boolean is the most common lie in a data pipeline: done according to what? the same source? the same settings? the same output? Recall never trusts one flag. It layers identity so a changed source, a changed audio configuration, a changed provider setting, and a changed release are each distinguishable — a ladder of hashes where every rung prevents one specific confusion. This track builds that ladder from the ground up: why one flag fails, how video identity differs from an observed-bytes fingerprint, the full ten-layer scheme, and why even --force does not authorize a blind paid rerun.

   Lesson list (4)

   • 01
     No Single Flag~10 min · single-flag, idempotency, staleness, cache-invalidation
   • 02
     Video vs Fingerprint~11 min · video-id, fingerprint, content-hash, cost-tiers
   • 03
     The Ten Layers~12 min · ten-layers, deduplication, identity-ladder, precision
   • 04
     Force Semantics~11 min · force, escape-hatch, money-boundary, scoped

   ✓Quiz · 4 questions→

6. 06🎫Leased Work

   0/5 lessons

   How hours-long jobs survive a crash, and the OS traps that shaped the design

   Transcribing thousands of videos means jobs that run for hours on an executor that can crash, hang, or be restarted at any moment. This track is how that work stays survivable: a lease with a token and a heartbeat so exactly one worker owns a job at a time, atomic reclaim when a lease expires, and a killable child process so an unresponsive network filesystem can't freeze the whole pipeline. It closes with two hard-won operating-system war stories — a background process that hangs on a synced path, and a permission model that denies file access to the wrong identity — because the cleanest design still has to survive the machine it runs on.

   Lesson list (5)

   • 01
     Lease Token + Heartbeat~11 min · lease, token, heartbeat, fencing
   • 02
     Expired Lease Reclaim~11 min · reclaim, atomicity, reconciliation, orphan-state
   • 03
     The Killable Child~12 min · killable-child, timeout, network-fs, process-isolation
   • 04
     The FileProvider Stall~11 min · war-story, launchd, runtime-snapshot, sync-path
   • 05
     The TCC Signed Launcher~11 min · war-story, permissions, code-signing, process-group

   ✓Quiz · 4 questions→

7. 07🚧Completion Is Not Approval

   0/4 lessons

   The wall between 'it finished' and 'it's good enough to be knowledge'

   The pipeline finished, the quality check is green, the transcript is searchable. Is it now trustworthy enough to feed a knowledge system? Recall's answer is a hard no by default, and this track is why. It builds the quarantine — corpus eligibility that starts excluded and can only advance through explicit human transitions — and shows why 'usable for finding a moment' and 'safe as a source of knowledge' are two genuinely different judgments. Then it turns to the product: why search indexes structured timestamped segments rather than mutable exports, and how a search hit becomes an editing action without ever letting a browser name a file.

   Lesson list (4)

   • 01
     The Quarantine~11 min · quarantine, default-deny, promotion, trust-boundary
   • 02
     Two Judgments~12 min · two-judgments, fitness-for-purpose, human-in-loop, risk
   • 03
     FTS Over Segments~11 min · fts, segments, inverted-index, derived
   • 04
     Search Is Editing~11 min · handoff, security, capability, confused-deputy

   ✓Quiz · 4 questions→

8. 08🏛️Own Your Archive

   0/4 lessons

   The index is derived, the binaries stay put, the brain lives elsewhere

   The closing discipline. Three boundaries hold the whole engine together: the index is derived and must be rebuilt rather than patched; the original video bytes stay where they live and Recall stores references, never copies; and the engine owns its archive domain while judgment stays with the brain it borrows. Each is a refusal — refusing to patch, refusing to hoard, refusing to grow a second identity — and together they're what makes an engine that lasts. The final lesson turns the whole quest outward: not so you can run Recall, but so you can build the thing Recall taught you to build.

   Lesson list (4)

   • 01
     The Index Is Derived~11 min · derived, purge-and-replay, single-source-of-truth, no-patching
   • 02
     The NAS Owns the Binaries~11 min · references, storage-ownership, tombstone, no-hoarding
   • 03
     No Brain of Its Own~11 min · no-own-brain, bounded-context, separation-of-concerns, boundaries
   • 04
     Build Your Own~12 min · closing, conceptual-opensourcing, synthesis, build-your-own

   ✓Quiz · 4 questions→