ai-labs
ai-labs/context-v/
51 files here · 541 in 8 sub-projects
Sub-projects
specs/72
Survey: a Scoped Dashboard of context-v
One command turns every context-v/ folder in scope into a dashboard, a task list, and a map, the way graphify turns code into a graph.
MemoPop Connector API
Ten tools, one step registry, and the docs and tests that ship with each. What we build so a partner's Claude can write a MemoPop memo.
SearchBox — LiveFilter and Autocomplete
A subsidiary spec. Two named variants over one private core, because the keyboard contract must exist exactly once and the two differ only in where options come from.
The component API contract and the control scale — inspired by shadcn, with sprinkles of Tailwind, derived from what members already built
Members were already converging on Tailwind's radius scale by instinct. They just had no token to spell it with.
Design System Convergence — the organ registry, its five verdicts, and the fingerprint ledger that catches drift while it happens
The registry is what makes drift legible: a declared organ is a decision, an undeclared one is drift. The code can be identical in both cases.
id.didi.sh — the Didi Identity Service
One owned identity service: headless-first API, a signed session cookie on `.didi.sh`, invite-only accounts — built on Elixir/Phoenix.
Header Chrome
The workspace becomes a switcher, not a label. The mode toggle shows one icon and says what the next click gets you.
Ranked Search — Pagefind over the manifest
Substring matching cannot rank, stem, or take two words in any order. Pagefind can. It indexes the manifest, and never replaces it.
Search Index — the manifest that stops search reading the corpus
A search opens every file: 845 reads, up to 5.8 seconds. A manifest in the corpus makes it one, and closes the gap FOCUS-07 named.
Strategy Focus
A strategy chip narrows the list and compounds with search. The corpus count rides alongside, so a subset always says what it is a subset of.
Binary Ingest and the bin/ Store — one copy, optimized, fetched on demand
78 files are 90.5% of the corpus bytes. Compress once, store once by hash, fetch when asked, delete locally without fear.
Corpus Change Feed — what changed in a client's corpus, and why
A change record any history engine can emit, and a feed that renders it for someone who will never read a diff.
Corpus Tree
A corpus is a folder the client can't see. The tree is built from keys alone, so showing 944 files costs zero reads.
Domain Navigation
112 folders in a dropdown is a list you scroll, not a list you use. Type any near-match; backspace walks back a segment at a time.
Flave — An Agent-Native Document Format and Desktop Publisher
The master spec. A package format (.flave) and an editor built on Lossless Flavored Markdown — a document that keeps its workings, publishes only what you choose, and is written in the languages agents already speak fluently.
Federated Component Libraries
One gallery runtime, seventeen sovereign catalogs — every member publishes what it is made of, at its own address.
Browse Corpus — a screen for the work that already exists
The first surface: read-only over reach-edu's 892 existing files. Pulled out of Phase 7 because Tauri was never the cheapest first screen.
Capture From The Screen — the surface stops being a viewer
Paste a URL and watch it get filed. Writing is opt-in at the server (`--writable`) because the first corpus this screen saw was a client's.
Capture, Link-First — the first command that pays for itself
`corpora add <url>` fetches, names, dedupes, and files a link as a source — metadata-only by default, because bulk enrichment goes haywire.
Loop Harness — the ledger that lets an agent run unattended
Spec IDs bind to test functions, status is derived by running the suite, and a promise with no test is a build failure.
Source-File Model — the schema becomes code, and two silent failures become loud
The schema as a round-tripping dataclass — the stray `---` that hid 13 of ImmuneCo's 93 sources is now a hard error, not a silent one.
Storage Seam — one interface, three implementations, and the workspace that names the bucket
A CorpusStore over local, R2, and cache, proven by one conformance suite that runs against every backend with no test-side branching.
Source Content Storage — SurrealDB-Primary, Local as a Per-User Toggle
Flip the content store: the article body moves onto the canonical `sources` row and the local filesystem write demotes to a toggle.
MVP: context-v as a Claude Code Plugin
The kit's MVP is not the Chroma memory system the June specs planned — it's a plugin where `/plugin install` is the whole onboarding.
Corpora Builder Harmony — the evolving test registry
Every proposed and implemented test guarding the corpora builder and the systems it must harmonize with — identity, workspace connector, transport, state, canonical layer, files — in human language, MECE, one ✓-phrase each.
Design System Portal
Specification for the portal that renders the federated design system — the swatch page, the token catalogue, the member index.
Federated Design System Architecture
The organising specification for augment-it's two-tier, seventeen-member design system.
Augment from DB — the Org Workbench + Search-and-Add flow: two new microfrontends over capabilities that mostly exist
Start from a canonical org, not a CSV row: an org workbench over links, streams, corpus and people, plus provider-pluggable search-and-add.
Entity-Card Edit & Remove Affordances — every visible property gets a micro-button pair
The org card views and edits in place, but only additively — a misclicked ➕ today required a direct database write to undo. Every entry and identity property the card shows grows ✎ and × micro-buttons.
Search-Results Queue — a right-rail microfrontend where concurrent agent searches land, signal, and get triaged
Agent searches run minutes; the operator shouldn't. Every search becomes a card in a persistent right rail — fire many, triage on arrival.
Connector Inventory & Per-Record Palette — Hot-Swap Providers, Re-Fire One Record at a Time
Per-record connector palette: click `f` to re-fire one row through the next Facebook provider, over a registry that resolves by capability.
Strategy Curator — An Entry-Point App for augment-it
A canonical source registry in SurrealDB owns identity, the client's filesystem owns usage, and a shared UUID is the only bond.
Entity-Pulse Bundle — Press Releases, News Mentions, and the Social Voice of a Record
Official Updates fires first; its rollup becomes the relevance prior for Media and Socials Mentions — a foundation-first four-phase DAG.
Pulse pattern — one operator burst against one entity, expressed as N independent pulse-dimensions composed in a pulse-surface, each dimension potentially owning its own microservice
Operators enrich in bursts, not steps: one search fills name, socials, emails, and org, and a pulse-surface commits all of it in one save.
Record ↔ DB Resolver — operator-driven match/create bridge from row-store records to canonical organizations
Row-store records and canonical SurrealDB orgs were never bridged; the resolver closes the gap one record at a time, operator driving.
Sparse-Person Enrichment Surface — per-email triage where the operator finds the human behind the address, picks or creates the org they belong to, and writes both back to the canonical layer
177 event attendees landed as 177 bare emails — the opposite shape from the URL-bearing records every other augment-it flow assumes.
Augment from Affiliations — the first flow that starts from SurrealDB instead of a CSV, turning an event's speaker/org pairs into a rated, sourced prospect list
The first flow that starts in the canonical layer, not a CSV: export an event's affiliations, rate relevance offline, reimport.
The Source Curation Surface — A Component Architecture for a Svelte Rebuild
Decomposes a proven single-file curation tool into Svelte components: a runes store, a tree of small components, one API contract.
Workspaces as Tenant Primitive — toggling, tenant-aware microservices, per-tenant env-var pickup, and the seam that lets MCPs and connectors vary per client
`workspace` is the tenant boundary — humain-vc vs reach-edu. The vision is stated once, then step 1 is cut down to filesystem-only bones.
Client tagging on canonical writes — every observation carries the client that produced it, and every canonical entity carries the materialized set of clients that can see it
The canonical layer is cross-client by design — a materialized `client_access` array is how each workspace still sees only its own.
Records Surface sort step and UI — sort ships as part of the **Sort & Filter Lens**, the second lens in step 2's default set (alongside the existing **Pack Firing Lens**); `lens` is the architectural primitive this spec introduces and lenses are *swappable* (one active per step at a time), not stackable; each step ships with a small curated default lens set and the registry stays *open* so new lenses can join without architecture changes
Sort ships as the second swappable lens on step 2 — and the lens registry is open, so a new lens is a manifest drop, not an enum edit.
Chat Context-Awareness Architecture — three layers (workspace as context broker, slab-assembly contract, verb registry) that grow the in-app chat from prompt-only to surface-aware verb router
Chat's verb roster is a hand-written prose block and its context slab carries only `record_set_id`; this closes both holes.
Corpus Inbox — capture first, triage later; a zero-friction save destination for URLs without a home yet, with a future triage layer that sorts inbox content into the right places
A URL with no home yet shouldn't cost a filing decision: `corpus/inbox/` captures the page, its body, and a drive-by note, then waits.
Funder Content Corpus Workflow — what the system has to do, ranked by quality bar, with no implementation prescribed
Written so a future agent resists the pull to filter yesterday's bad data tighter instead of firing fresh for today's good data.
Record-Set Family Grouping — internal lineage vs. external-variant families in the Record Collector sidebar
The sidebar shows a tracker uploaded as v4–v8 as five unrelated CSVs. Two family kinds — promotion lineage and external variant — fix that.
Response Reviewer Shell and Content-Reader Mode — Response Reviewer becomes a wrapper whose inner review UI swaps based on what the bundle that fired actually produced
1,109 OfficialPulse responses, 3 accepts: 'is this URL right?' is the wrong question for content packs, so review mode becomes swappable.
Flow for Bundles & Packs — The Simplest Possible Thing
For 67 rows with a website URL, find each one's blog index. Two surfaces, no reviewers — this spec deliberately ignores the five before it.
Per-Record Iteration as the Primary Surface for Pack and Bundle Fires — The Flow Rearranges Per Fire Type
A pack fired across 96 rows returned 0 found — so per-record iteration becomes primary and bulk fan-out waits until a chain is proven.
Pulse Curation Layer & UI — Three Layers per Category, Triage Per Item, Finalize on Demand
Three layers per category: immutable `raw_output`, live `curated_output`, and a `finalized_output` snapshot locked when triage is done.
Shell & Micro-Frontend UX Coherence — Affordances That Are Found, Consistent, and Talk Back
A demo-prep chain of 'I can't find / reach / trigger X' is a verdict: the shell's affordances hide, die, or mismatch. Fix the pattern.
Tooltip System — A Versatile First-Class Family, Plus a Walkthrough for New and Returning Users
Apps fail at orientation, not functionality — so tooltips become a first-class family, not the browser's half-working `title=`.
Commands and Agent Skills for context-v
Catalog of every command, slash command, and agent skill the kit ships — surfaced natively via `.claude/commands/` and `.claude/skills/`.
Enhanced Records List — the Triage Checkpoint and the Promotion Loop
One record-grained view of a whole enrichment round: select the good rows, promote them to canonical, and the predecessors archive.
Request Reviewer — the Pre-Flight Surface
See exactly what is about to leave the building — and guarantee the request you reviewed is byte-identical to the one that fires.
Response Reviewer and Response Store — the Post-Flight Surface
No review surface until a fired response is a first-class stored object — so response-store and response-reviewer are specced as one.
Walking-Skeleton Pre-Flight Decisions — Augment-It Rewrite
Five substrate decisions — state, transport, persistence, auth, agent scaffolding — settled before code so no session re-walks the tree.
Augment-It as a CRM-Augmentation Pipeline (Microfrontends + Microservices)
memopop makes memos, dididecks makes slides, augment-it makes information that lands back in a CRM it doesn't own.
In-App Agent Chat — Core Package Spec
One package — capability registry, BYOK proxy contract, chat UI API, transcript schema — targeting web and Tauri, proven first on dididecks.
Introducing a Content Density Mode System
A system-level content mode toggle (redundant vs concise) that alters the behavior of the writer, table generator, and quality agents to match different firm preferences for information density and repetition.
Introducing a Diagram Generator Agent
Add a diagram_generator.py agent that identifies opportunities to create visual diagrams explaining complex business concepts, starting with TAM/SAM/SOM market sizing and expanding to common finance and consulting visuals.
PDF Parser Agent Specification
A small specification for an agent and script to parse PDFs and convert them to markdown with properly formatted citations.
Multi-Agent Orchestration for Investment Memo Generation
An exploration into using AI supervisors and specialized agents to generate high-quality content and documents.
Portfolio Listing Agent and Current Portfolio Section
Design notes for the portfolio_listing_agent that builds a Current Portfolio subsection and structured JSON for LP-commit emerging manager fund memos.
ai-labs/specs
augment-it/specs
context-vigilance-kit/specs
corpora-builder/specs
dididecks-ai/specs
flave-ai/specs
memopop-ai/specs
memopop-native/specs
memopop-orchestrator/specs
plans/87
Plan: Retrofit Every Repo to OKF, Then to the Kit's Frontmatter
The kit made every doc declare a type. 945 older docs across 47 repos don't, yet. Here's the sweep that fixes it.
MemoPop Connector API, Phase 7: The Plugin and Real Claude
A thin skill that keeps Claude on the method, packaged with the connector, and a test where real Claude writes the fixture memo.
OAuth Authorization Server for Claude Connectors
Discovery, authorize, token, refresh, and client registration on id.didi.sh, so Claude can sign a partner into MemoPop with one magic link.
MemoPop Connector API, Phase 1: Foundation
The registry, errors, auth, storage, five tools, the docs generators, the ledger, and CI. Every later phase builds on this one.
MemoPop Connector API, Phase 2: Deploy
A container with every system tool the memo needs, running on Railway at memopop.didi.sh, watched by a health check every 30 minutes.
MemoPop Connector API, Phase 4: Materials
Decks, datarooms, notes, and links reach the server three ways, become text the steps can read, and never block the memo.
MemoPop Connector API, Phase 5: Enhancements, Compile, and the Full Flow
Every enhancement becomes a step that can skip, compile turns sections into a branded PDF, and a scripted client walks the whole memo.
MemoPop Connector API, Phase 6: History and Snapshots
Every saved artifact becomes a jj change the client never sees, and one save backs the firm's whole workspace up to its bucket.
Phase 2 — The Workspace and the Files Surface
Flave opens a folder, shows you what is in it, and lets you edit the theme that styles what you are reading — so design work is brought in once and reused, never recreated.
Analyze Harness-like Evidence in a Collaborator Codebase
Step 1 of 3: read a collaborator's repo for every sign of how they work with coding agents, and inventory it with paths and dates.
Compare and Contrast Harness-like Artifacts between Lossless and a Collaborator
Step 2 of 3: set our harness beside theirs. What's shared, similar, different, missing, and what each side should do about it.
Generate an HTML Page for Lossless and a Collaborator, Rendered in the AI Labs Splash
Step 3 of 3: turn the evidence and the comparison into one splash page. Visual highlights up top, the detailed narrative below.
Build Selector and close the keyboard contract
Nine surfaces declare a keyboard widget. Zero implement one. This is the first component whose whole substance is behaviour, so it is the first one with real tests.
Give the services a shared tsconfig base — fold ten byte-identical service configs onto a new `tsconfig.services.json`, reconcile `decile-mcp`'s real delta, fold two duplicated package configs onto the existing `tsconfig.base.json`, and correct the root fallback's stale exclude list
Ten service tsconfigs are byte-identical and extend nothing. The fix already exists one directory away — `tsconfig.base.json` did this for the apps and works.
Prove the component API end-to-end on request-reviewer — ship the scales, build Button, migrate one member, and verify by measurement
If this loop closes once it closes eighteen more times. One member, nine buttons, and a measurable accessibility delta.
Tidy every consumer onto the shared primitives
Button is done across nineteen units. This sequences what is left: Chip everywhere, the stale annotations, and the three containment jobs that are not component work at all.
Component-Level Documentation Contracts — Giving All Forty Units Their Own Four Firsts
Forty deployable units, fourteen READMEs, zero DESIGN.md files. The contract set each kind of unit owes, and the order to pay it down in.
Graphify as Standing Practice and Per-Component Diagrams — Visual Engineering That Doesn't Go Stale
The graph ran once, on 2026-08-06, and still names an app that was renamed two days later. Turning a snapshot into an instrument, and giving each unit its own picture.
Pickup notes — 2026-09-12: the watchdog got fixed, and so did the bug it was never going to catch
A "Twenty is broken" report that wasn't, a production bug that only appears on a dead socket, and three days of infrastructure that lives outside git.
Stale Corpus Sources When the Workspace Socket Is Down — the header moves, the list doesn't
Switching corpora on a dead socket silently shows another corpus's sources under the new name — a wrong answer wearing a confident label.
Back Up the Content-Ingest Corpus Volume — the corpus has no second copy
Every fetch writes to a single Railway volume that nothing backs up, nothing mirrors, and only one process can even read.
Fix Env Aliasing That Drops PUBLIC_ Vars in the Developers Menu
Assigning import.meta.env to a variable defeats rsbuild's static replacement, so two production URLs quietly resolve to localhost.
Re-Mint the Deploy-Watch Railway Token — the watchdog has been blind for days
The watchdog built so a failed deploy would not go unnoticed for twelve days has never once run green itself.
corpora-builder on didi.sh Entities — signup, login, and who sees which corpus
The tenancy primitive is already built and it's flat. corpora-builder should inherit it, not invent a second one.
didi.sh Login and Workspace-Delivered Config — the plan across three repos
corpora-builder should get its config — R2 credentials included — from the didi.sh workspace, not a local `.env`.
didi.sh Auth and Multi-Org Corpora
Log in once, hold several organizations at once, and read one federated corpus across them. Three catches, and two specs that disagree.
Search Index, Then Pagefind
Search reads 845 files. Phase 1 writes a manifest so it reads one. Phase 2 puts Pagefind on top of that manifest, not in place of it.
Sync Corpora to R2, and Show Clients What Changed
The R2 prefix has held zero objects for fourteen days — and the corpus grew anyway, in git. Mirror first, version later.
Phase 0 — The Live Render Loop
Type Lossless Flavored Markdown, watch it become a styled document as you type, and invent new syntax without touching the renderer. The smallest thing that is already the product.
Phase 1 — One Operation Set, Four Callers
A menu, a palette, a rendered page you can type into, and an agent — all writing through the same named operations, so a human and an agent can never reach a state the other cannot describe.
Reconciling Perplexity Citations Against Retrieved Sources
Sonar hands us the sources it actually retrieved on every call, and we throw them away — so every URL in every memo is a guess.
Codify the deck design system & component library — author DESIGN.md, showcase it on /design-system, and refactor every kept element onto theme/mode tokens
Building six strategy decks produced a real, reusable design system — deck-primitives.css (a 15-class component vocabulary) plus a set of recurring section compositions (cover, stat slide, field template, two-column contrast, numbered flow, accent callout, tier cards, ask/close). None of it is documented or shown on /design-system, and there is no DESIGN.md. This plan codifies the system: author a DESIGN.md per the maintain-design-md (Google Stitch) spec, add the deck primitives + patterns to the /design-system page, and — the gating discipline — promote an element into the documented system ONLY once it reads the Tier-2 semantic + --fx-* tokens and works in light/dark/vibrant with no hardcoded colors. That last bar is what 'requires refactoring': the strategy decks are already token-driven, but the older story/automation/homepage sections hardcode dark:/vibrant: triples and must be reconciled (or explicitly excluded) for one coherent system.
16:9 Export Variant (Play-UI) and the PPT/PDF Pipeline
Plan for the fixed-aspect, no-scroll, no-animation variant of each strategy pitch deck — the Play-UI conversion per the DidiDecks discipline — plus a native-shapes PPT exporter tuned for clean Google Slides import, and PDF via the shell's print route. Written 2026-07-28 while building the Scroll-UI decks, so the conversion is anticipated, not retrofitted.
Test coverage — pick the harness, seed the suite from the prove-scripts, and loop the open bugs to green
Vitest + Playwright for this repo, ExUnit already standing in id-didi-sh — convert the six prove-scripts into a permanent suite, then write the humain-vc corpora bugs as failing tests and iterate until they pass.
Open augment.didi.sh to reach-edu — a second tenant instance, and Stephenie Tesoro as the first client user
The data is already deployed; only the door is single-tenant. Open it with a per-client instance, not a relaxed org check.
CRM Starter Export — the pipeline shape, enriched from the canonical layer: orgs first, then people attached
Two CSVs seed the empty CRM from the canonical layer: organizations first, people second, attached by a stable key. Corpora excluded.
Org Relations (parent/child/peer) + Org Tags — model, capabilities, and the Org Workbench surface
Organizations finally get edges to each other — parent, child, or peer, with a typed flavor and free-text human context — plus their first tag mechanism (Initiative, Program, Funder), all workable from the Org Workbench card.
Didi crawl — three targets (links, streams, team members), the relevance brief, and staged team ingest
One `organization.crawl` capability over Anthropic's server-side web_search, driven by a per-workspace, operator-editable relevance brief.
Workbench usability sweep — corpus visibility, stream editing, and promote-to-affiliation (issues #20 · #26 · #25)
Today's scope from the first real workbench session: make the person card's three invisible corpus items visible, let the operator fix a stream's kind and give it its real name, and turn a bio-page link row into a three-click affiliation.
Workspace-scope legibility — empty workspaces and stale org restores should explain themselves, not look broken
Switching to a workspace with 0 orgs made the workbench look dead — the visibility rules were right, only the messaging failed.
Augment from DB · Phase 1 — service capabilities + Exa, no UI
Four service-side deliverables that make the whole flow provable from a script before any remote exists: org detail + org affiliations reads, a registry-resolved search.fire, and Exa as a peer connector.
Augment from DB · Phase 2 — the org-workbench remote: flow registration, org search, org card
Autocomplete to a canonical org and work its card with a live ➕ on every list — plus the verb the spec missed, `organization.streams.add`.
Augment from DB · Phase 3 — the search-and-add remote: editable term, provider palette, one-click add
Launched from any 🔍 on the org card: an always-editable term bar, a provider palette, one-click add back to the launching list.
Augment from DB · Phase 4 — people reveal, person cards, add-person with automatic affiliation
The org card grows its people: every affiliated person revealed with role + relevance, nested identity links with their own ➕ and 🔍, and an inline add-person where the affiliation edge materializes without the operator ever managing it.
Augment from DB · Phase 5 — stream-scan mode: scan a pulse stream, badge the already-known, one-click the new into the corpus
Stream scan is a mode of search-and-add, not a third remote: the stream URL is the authoritative index, deduped against `content_items`.
Plan stub: ingest the next reach-edu event CSV into the canonical layer
The mechanism already exists and is proven twice over (turning-jobs, FreedomFest) — this is the sequence to run the moment the next event CSV lands, so it's 'follow the stub' instead of 're-derive the pipeline.'
Study Agent Harnesses + Conversational UI, Then Decide the Cross-Product Native Shell
Pin two studies and audit in-house prior art before designing a Tauri shell that swaps context across three apps. No code lands here.
Pickup notes — 2026-07-13: deploy hardening, doc audits, credential hygiene
Steps 1–10 are live at augment.didi.sh; this session cleared the production-only bugs that only using the deployed app surfaced.
Build order: the humain-vc unlock flow, step by step
The execution sequence for Flow 1 — each step names its repo, files, and verification, so a fresh session can pick up mid-sequence.
SurrealDB MCP + a verification skill — querying augment-it's canonical layer directly, starting with FreedomFest 2026
Person-aware canonical resolver — closing the gap between the proven scripts and the shell-reachable capability
The resolver only knows organizations; every person and affiliation ever written came from CLI scripts no UI can reach.
SurrealDB MCP + a verification skill — querying augment-it's canonical layer directly, starting with FreedomFest 2026
Unlock: the humain-vc team (two people) logs into a deployed augment-it
One flow: a humain-vc member signs in with her work email, lands in her workspace, works the thesis corpus. Single-tenant deploy on purpose.
Migrate off the deprecated `nats` package to the `@nats-io/*` scoped v3 client — swap `nats@2` for `@nats-io/transport-node@3` across all 10 services, drop the removed `JSONCodec` in favor of `JSON.stringify` + `msg.json()`, and prove the inter-service bus still round-trips live before committing
`nats` → `@nats-io/transport-node` v3 across 27 files: mechanical, except the removed `JSONCodec` rewrites every encode and decode.
First-Pass Corpus Quality Scan for reach-edu — a measured before/after baseline of the RAG corpus
A read-only baseline of 517 markdown files across 57 funder dirs, taken before RAG is wired, so 'after' has a 'before' to compare to.
Canonical Entity Registry on SurrealDB Cloud — just write records
SurrealDB Cloud is up at main/main with three SCHEMALESS tables (persons, organizations, affiliations). Goal: write records from tonight's CSV+JSONL into those tables. SCHEMALESS stays. No field discipline up front.
Augmentation-state preservation and snapshot promotion — the operator's CSV is the system of record, the filesystem is the truth, and `/promote-snapshot` is the verb that walks the corpus and emits the next CSV with system columns appended so flow-switches don't erase the prior cycle's work
One verb: `/promote-snapshot` joins the corpus filesystem into a fresh CSV version with system columns. No register, no write-hooks.
Download PDFs into Corpus Inbox — preserve the original binary alongside Jina-extracted markdown; wire both inbox vectors (UI and agent-chat) so the operator's PDF discoveries land as commit-able evidence, not just summarized text
Jina gives the inbox text and throws the PDF away — nothing to cite by page or hand to a co-researcher. Save the binary alongside it.
URL Auto-Detector and Clickable Rendering for List Fields — make socials, helpful_links, and official_updates_index_urls open-in-tab links instead of opaque JSON
`socials` and its list-shaped siblings render as 12px JSON; a shape-detecting extractor makes every URL clickable and drops the clutter.
In-App Chat v0.0.1 for Augment-It — The Prompt-Drafting Triad as the Demo Affordance
Gated enhancement made conversational: `prompts.draft` → `improve` → `apply`, with postconditions that check what the prompt promised.
Shell & Micro-Frontend UX Coherence — Refactor Plan
Eight locked UX decisions sequenced into five phases — the Deck→Flow rename first, so every later phase speaks the right vocabulary.
Augment-It Workspace — Walking Skeleton Plan
Browser ↔ Workspace Service over WebSocket, Workspace Service ↔ row-store over NATS, and two real spreadsheets as the proof-of-life payload.
Impose the Three-Mode Theme System on augment-it
The two-tier tokens and light/dark/vibrant contract adapted to a federated, Tailwind-less app: one shared `packages/theme`, no raw hex.
Prompt-Template-Manager — Walking Skeleton Plan
Author `{{column}}` templates and run them per row — `prompt-runner` is the only container that calls the Anthropic API.
Run-as-First-Class-Operation — Pair Pack-Runner with Prompt-Template-Manager, Make Runs Legible Across the Pipeline
Lift `Run` from a string id buried on each response into a real entity, so any surface can see which batch produced what it's showing.
In-App Agent Chat — Walking Skeleton Plan
One session's work: scaffold the package, do the Chroma tenant migration, and ship `slide.read` end-to-end as proof the abstractions hold.
Agent Capabilities — Hooking the Chat Surface into Memopop
How the In-App Agent Chat pattern maps onto memopop-ai: where each layer lands in the repo, and the smallest read-only proof-of-life.
The Anatomy of the In-App Agent Shell — Shell, Workspace, Window, Chat
"Shell" meant four things at once: layout frame, workspace package, Window, chat. The workspace is the source of truth — not the chat.
Per-App Workspaces and the Chat as Optional Surface — The Architecture We Walked To
State of truth lives per app in `@<app>/workspace`. The chat package is UI-only, reaching it through a typed WorkspaceAdapter.
Init DidiDecks as Core Submodule of AI-Labs
Carve dididecks-ai out into its own repo and re-attach it to ai-labs as a git submodule, with branch-aligned tiers.
Refactor scroll-ported slides into true static play-format slides (per-client, repeat for every deck)
A reusable procedure for stripping scroll idioms — vw/vh units, reveals, marquees — from copied slides so `/play` and `/print` render them.
Add a Chroma Local UI Interface
Local Chroma in PersistentClient mode is an embedded SQLite library with no UI of its own. Three paths to a browseable surface — from a 30-line inspect script tonight to a /chroma route in the splash later — laid out in increasing commitment.
Context Vigilance Splash Page — Narrative Brief
Designer brief for the Context Vigilance splash. The functional plumbing exists; the structural skills are codified elsewhere. This doc is only about the *story* — the four-act narrative arc and the emotional move each act should produce.
Track and Ingest Lossless Content into Chroma (with Change Detection)
A second ingestion pipeline parallel to the context-v corpus — for the ~5K Lossless content files scattered across the monorepo. Driven by its own sources map, with content-hash-based change detection so re-runs only re-embed what actually changed.
Write Custom Chroma MCP Server (v0: a session-transcript ingester)
Defer djm81/chroma_mcp_server; write our own session-transcript ingester into the Chroma the corpus lives in, so the two cross-query.
Migrate `studies/open-specs-and-standards/` into its own pseudo-monorepo
ai-labs/plans
augment-it/plans
context-vigilance-kit/plans
corpora-builder/plans
dididecks-ai/plans
flave-ai/plans
id-didi-sh/plans
memopop-ai/plans
memopop-orchestrator/plans
reach-edu-hub/plans
studies/plans
prompts/13
Kickoff: Collaborator Codebase Analysis
Act as VP of Engineering: run three subagents in sequence to compare a collaborator's agentic-coding harness with ours.
Create a New Study
Common-Six Social Packs — First Real Packs on the Structured-Output Surface
Six pack identities — linkedin, x, bluesky, youtube, facebook, wikipedia — on one backend routing by `pack_id`, no microfrontend per pack.
Helpful Links on Records — Captured During Response-Reviewer Triage
The adjacent links a human finds while triaging die in the clipboard; `helpful_links` catches them in one click and survives derivations.
Response Reviewer — Structured-Output Extension (Packs-and-Bundles Foundation)
Build the surface every pack lands on — candidate cards, confidence pills, outcome enum — against mock fixtures. Zero packs ship here.
Run /speckit-specify — Response Reviewer Structured-Output Extension (Packs-and-Bundles Feature 1)
Feature 1 of the packs-and-bundles series: the structured-output surface every pack will land on. Zero packs, zero bundles implemented.
Build the Shell Tiling & Peek-Deck — Window the Federated Frontends
The shell stops being a tab switcher: a peek-deck at 90% width with neighbours peeking, plus a two-remote split with a draggable seam.
Run /speckit-constitution — Seed Augment-It's Constitution from Context-V
The directive to paste with /speckit-constitution so the principles synthesize from our own context-v docs, not from training data.
Run /speckit-specify — Workspace + Sidecar Foundation (Feature 001)
The workspace package and bun sidecar, plus exactly one capability — `records.import` — end to end to prove the pipe. No federation yet.
augment-it/prompts
dididecks-ai/prompts
memopop-orchestrator/prompts
studies/prompts
blueprints/20
Augment-It as Working App and Architecture Demonstration
Augment-it is a working product and a live architecture showcase at once; every decision answers to both lenses so neither quietly wins.
Webhook as Wake-Up, Not as Truth — relaying platform events into CI without trusting them
Polling gets throttled and push payloads are unsigned. Forward the interrupt, not the claim, and both problems stop mattering at once.
Show the Filesystem of a Workspace
Every ai-labs app sits on a folder the user cannot see. The tree is the same five decisions each time; the backend is the only part that differs.
Shared Content Modules Across Deck Surfaces
One typed content module per deck variant drives Scroll-UI, Play-UI, and the PPTX exporter — so copy cannot drift between surfaces.
The Source Curation Gate — A Convergent Prune-and-Promote Surface for AI-Assisted Web Research
Three apps grew the same organ — a human prune-and-promote step between retrieval and generation that the writer cannot then escape.
Connecting To And Using SurrealDB
The one place that codifies how augment-it talks to SurrealDB Cloud — the five env vars, the connect → signin → use dance, the client-tagging write contract, and the dev-only-credentials posture that a proxy service eventually replaces.
Install Auth Across Applied AI Labs Apps
Don't re-derive the auth pattern — astro-knots already shipped it. This is the ai-labs handle: what to pull in, which DB, what to translate.
Response–Row Identity Across Promote — Why Responses Outlive Their Rows, and the `record_uuid`-on-Response Fix
Promote deletes parent rows, leaving responses pointed at dead `row_id`s; carrying `record_uuid` on the response resolves them by identity.
Packs and Bundles — The Two-Tier Pattern for Entity-Profile Augmentation (and Beyond)
Two tiers: a pack is one source, one remote, one schema; a bundle is a named composition of packs fired by a single chat verb.
Chat-As-Verb-Surface Patterns — How the In-App Chat Calls Skills, MCP Tools, and Scripts; How it Reads State and Anticipates Lightly
Five conventions that let three apps share a chat surface without sharing a package, starting with capability adapters and one envelope.
Per-App Workspace Conventions — Discipline, Not a Shared Package
No universal `@lossless/workspace` package. What every app shares is the shape: singleton state, an activeView union, a capability registry.
Original and Enhanced Record Instances — the Record-Instance Model
No mutation, no derived set per run: one immutable original plus one mutable enhanced instance per round, promoted to seed the next.
Module Federation + Rsbuild — Dev Loop Gotchas
Five Rsbuild + Module Federation gotchas, cross-origin HMR first: none block adoption, all cost time if you don't see them coming.
Spec-Kit and Context-V Coexistence — How They Work Together in Augment-It
context-v holds the project's living memory; spec-kit drives per-feature implementation flow. Complementary, not competing.
Why Response Reviewer and Highlight Collector Exist — The Verbose-Prose-to-Tabular Bridge
CRM cells are terse and LLM answers are prose; no structured-output regime removes the human integrity check that bridges them.
ai-labs/blueprints
augment-it/blueprints
corpora-builder/blueprints
dididecks-ai/blueprints
memopop-orchestrator/blueprints
reminders/21
Every Step Writes Its Output To File
A run's destination folder is decided before the first step, and every step writes its result there as it finishes. Nothing lives only in memory.
Normalize Labels Gradually
One company says Total Revenue, another says Gross Revenue, a third says Top Line. One reports monthly, another quarterly, another H1/H2, another only annually. Collection never touches any of it. Normalization is a later, corpus-level act — a cluster of labels that mean the same thing, one chosen default, and an alias map — built by a person from real analysis across real portfolios, never by an agent guessing from what the words sound like.
Round-Closing Timeline Nuances
Wires arrive before and after the close they belong to, rounds close later than anyone planned, and a fund and its SPV subscribe months apart on identical terms. None of that is an anomaly. Record every date as the document states it, never revise one to make a sequence tidy, and confine anomaly-noticing to the handful of series that are actually real at this stage — money spent, web traffic, signed contracts, billed subscription revenue. Everything else is a claim or a projection, and instinctive concerns about it belong in anomalies.json rather than in the memo or the conversation.
The Sidecar Port Is Adopted, Not Owned
Tauri probes 8787 and uses whatever answers. A stray dev sidecar becomes the app's backend, silently, and the app looks fine.
Long-Running Is Not a Reason to Fan Out
Duration is not the variable that decides whether work should be split across agents. Continuity is. Ask before parallelizing anything whose quality depends on what came before it.
corpora-builder Is Not augment-it Tooling
It was born inside augment-it and split out. The relationship is inheritance, not overlap — and its purpose is bigger than either app.
Load the theme system before touching tokens
Three layers, two axes, three modes. And the ai-labs palette is augment-it's — not the shared-styles package nothing renders.
Never Run jj in a Git LFS Repo
jj does not run smudge/clean filters. In an LFS repo it commits the real bytes over the pointers — 282 MB in one save.
Dates are UTC at rest, viewer-local at render
Libraries We Do Not Use — Ever
A hard denylist of packages this codebase has removed on purpose. Do not import them, do not assume they are installed, do not re-add them.
Never Use JSX Syntax
Tags Are Two Projections — Frontmatter `tags:` on Files, `has_tag` Observations in SurrealDB
Files say `tags:` because Obsidian reads files; the DB says `has_tag` because its predicates are verb-shaped. Same fact, two projections.
The canonical spec lives in the ai-labs parent, not here
This repo's context-v/ holds implementation-local docs only. The spec of record — contract, session model, schema, increments — is ai-labs/context-v/specs/Id-Didi-Sh-Identity-Service.md. Read it before changing anything load-bearing.
Record Count Stays Stable Across Versions — Augmenting Adds Columns, Never Rows
One dataset, one row count, forever — augmenting adds columns, not rows. 231 rows in the store for a 96-record dataset is a symptom.
Preferred Stack — uv over pip, and other defaults
ai-labs/reminders
augment-it/reminders
corpora-builder/reminders
dididecks-ai/reminders
id-didi-sh/reminders
memopop-orchestrator/reminders
agent-skills/14
Loops — recurring maintenance disciplines that keep the repo legible over time
A new context-v category for skills that aren't one-shot specs or plans but **recurring rhythms** — the small, regular maintenance moves that keep a fast-moving repo readable to humans + agents who weren't there when the work happened. Each loop lives as its own subdirectory with a SKILL.md, optional scripts/, and templates/. Companion concept (TBD): `context-v/pairing/` for human-agent collaboration disciplines.
augment-it/agent-skills/decile-hub-interface/skill
The operator-facing workflow layer for getting real-world data INTO and OUT OF a client's Decile Hub CRM — sitting on top of the decile-hub-connector API contract. Use whenever importing a batch of real records into Decile (voice-note transcripts, CSV lead lists, LP rosters, event attendees), matching hand-collected records to existing Decile prospects by name, appending notes to people/prospects, or reasoning about the People-vs-Organizations-vs-Pipelines-vs-Prospects data model for a fundraising pipeline. Triggers when the user says "import these into Decile", "add these to the pipeline", "match these to Decile", "put these voice notes / this list into Decile", "attach a note to the prospect", "which pipeline do these belong to", or names the importer script decile-import-voicenotes.mjs. Encodes the read-only introspection recipe (whoami → pipelines?kind=investor → stages → prospect shape), the name-matching import pattern (Apple Voice Memos and most hand-collected records carry NO email, so the filename/typed-name is the identity key and Decile supplies the rest), where notes actually land (the Person/prospectable, NOT the pipeline row — so they surface across every pipeline that Person is in, tied to one pipeline only by the note's context label), the idempotent + additive + dry-run-first import discipline, the aliases.json spelling-bridge, and the .env gotchas that silently break the connector. The authoritative API contract is [[decile-hub-connector]] + the on-disk swagger; this skill is how a human operator drives it.
augment-it/agent-skills/inbox-curation/skill
didi's triage discipline for filing captured links and sources into the right corpus (thesis/strategy/topic) inside augment-it. Use whenever the user gives didi a URL to save, asks to "file this under <corpus name>", names an existing thesis/strategy by name for a link to go under, or it's unclear which corpus a captured link belongs to. Encodes the decision tree (named + existing corpus → source.add directly; new corpus → propose domain.create first; unclear → propose or park in the inbox), the domain-resolution discipline (resolve names against the live "Existing corpora" list, never fabricate a domain_type/domain_slug), and the boundary with corpus.inbox.add (the untriaged capture-first fallback). The capability catalog and args shapes live in services/workspace/src/chat.ts's CURATOR_CHAT_VERBS slab — this skill is the reasoning on top of it.
augment-it/agent-skills/triage-inbox-w-suggestions/skill
The operator+agent discipline for draining a client's corpus inbox (clients/<client>/corpus/inbox/) — agent scans each pending file, stamps a triage_suggestion, and proposes destinations in confidence-banded batches; the operator sweeps. Proven on the first co-pilot run (2026-07-25: reach-edu 141→4 in six batches); carries the run playbook, six-bucket org taxonomy, pointer/stream/gated routing, and reusable scripts/ helpers. Use whenever the user says "triage the inbox", "work through the inbox", "drain the inbox", "/triage-inbox", or asks to file/sort pending inbox captures. Encodes the destination model (funder org folder, person, or domain — with SurrealDB as the single canonical index and cheap reference .md copies fanned into any additionally-relevant folder), the six task lanes (TRIAGE/EXTRACT/ENRICH/DEDUPE/FLAG/DISCARD), the tagging convention (YAML array, Train-Case with lowercase connector words), and the batch/resume rhythm. Co-pilot phase: agent proposes, operator disposes; nothing files without an operator sweep.
dididecks-ai/agent-skills/loops/git-conventions/references/body-structure
dididecks-ai/agent-skills/loops/git-conventions/references/examples
dididecks-ai/agent-skills/loops/git-conventions/references/header-patterns
dididecks-ai/agent-skills/loops/git-conventions/skill
The Lossless Group's git commit message conventions — structured headers with action verbs and effort groupings, paragraph-spaced bodies that explain impact before implementation, and "Also included" riders for minor changes. Use when writing commit messages, reviewing commits, or when the user mentions "commit message format", "git conventions", or asks how to structure a commit.
dididecks-ai/agent-skills/loops/maintain-design-md/skill
How to author and maintain a `DESIGN.md` file at the root of any Lossless project (site, splash page, plugin landing, fundraise deck) following Google Stitch's open spec. Use whenever a project is missing a `DESIGN.md` and an agent needs the project's visual identity in machine-readable form; whenever the user mentions "design tokens", "design system", "DESIGN.md", or "Stitch spec"; whenever theme/CSS-token work changes the runtime values (new CSS custom property in `:root`, renamed token, new mode, new component pattern, refreshed palette, refreshed typography scale) and the documented contract has drifted; whenever a sibling skill (`generate-consistent-og-images`, `theme-system`, `astro-knots`) needs to read locked design values; whenever the user says "the agent doesn't know what color we use" or "let's write down the design system." Encodes (1) the Stitch spec's frontmatter token groups (colors, typography, rounded, spacing, components) and the eight prose sections in canonical order, (2) the maintenance triggers — what kinds of code changes should bounce back into the document, (3) the "runtime CSS is source of truth, DESIGN.md is the contract" discipline, (4) the precedent for off-spec extensions like an `imagery:` block, (5) anti-patterns. The skill never sees an API key or makes network calls — it's a pure-document discipline.
dididecks-ai/agent-skills/loops/maintain-design-md/templates/design-md-scaffold
★ One paragraph describing the visual identity. Mention the runtime source-of-truth path so future agents know where to read the actual values.
dididecks-ai/agent-skills/loops/maintain-filemap/skill
Use whenever the directory shape of a Lossless pseudomonorepo (or any child repo) changes — a new top-level directory is added, a submodule is mounted or unmounted, a major subsystem is renamed — or on a weekly cadence, or before any release that would land on GitHub, to regenerate the `FILEMAP.md` at each affected repo's root so collaborators see the current shape without cloning. Triggers when the user mentions "filemap", "tree", "directory layout", "repo overview", "what does this repo even contain", "new collaborator joining"; also when the agent itself proposes adding/removing a top-level dir or a submodule, because that's exactly the moment the discipline matters.
dididecks-ai/agent-skills/readme
dididecks-ai/agent-skills/setup-new-dddecks-workspace/skill
Scaffold a new dididecks-ai client workspace end-to-end — submodule scaffold under `client-sites/<slug>/`, DESIGN.md from the client's brand identity, theme tokens, auth-surface wiring, initial substantiation-corpus connection, and a Scroll-UI starter deck the deck-iteration-workflow can pick up from. Two source-of-branding modes — **website-parse** (crawl the client's public site for tokens, fonts, logos via `crawl-fetch-ingest`) and **source-code-copy** (lift `theme.css` / `DESIGN.md` / brand assets directly from an existing repo when the client is us, an adjacent Lossless property, or otherwise hands over their source). Use whenever a new engagement starts and a `client-sites/<slug>/` submodule does not yet exist; whenever the user says "set up a workspace for <client>", "scaffold a new client", "we have a new client", "spin up a deck site for <firm>"; whenever The Lossless Group itself or any other internal Lossless property needs a deck-site of its own (source-code-copy mode triggers automatically when the brand source is a sibling Lossless repo); and as the cloud-workspace evolves, whenever the equivalent flow needs to fire from a chat surface rather than a CLI. Composes the existing skills — does not re-implement them — for crawl-fetch-ingest, maintain-design-md, theme-system, generate-consistent-og-images, deck-iteration-workflow, and pseudomonorepos (the submodule and branch-tier discipline).
memopop-orchestrator/agent-skills/setup-new-firm/skill
End-to-end procedure for onboarding a new VC firm into the memopop investment-memo orchestrator. Five phases — (1) brand acquisition via Firecrawl with analyst-override on the primary-color heuristic, (2) firm-directory scaffolding under io/<firm>/ with the canonical configs/templates/assets/deals layout and the strict brand-config YAML schema, (3) investment-framework outline selection (typically forking an existing outline like alpha-partners-7-Cs and customizing — section reordering, preambles, preferred-source swaps, stage-aware fallbacks), (4) first deal setup with deck-input handling (DocSend capture via cli/capture_docsend.py, ImageMagick screenshot stitching for NDA-gated decks, deal-config JSON, codified Sources.md), and (5) optional private-repo split via gh CLI with submodule re-add for confidential firm data. Use whenever the user says "I have a new client/firm/VC," "set up <firm name>," "add <firm> to memopop," "we need brand configs for <firm>," or pastes a VC firm's URL with implicit intent to generate memos for them. Encodes lessons from the alpha-jwc onboarding on 2026-06-07 — don't trust Firecrawl's primary-color field blindly, verify against the logo palette; the deck analyst will extract DocSend watermarks as the company name if you feed it watermarked screenshots; agents leak firm-geography context into company-analysis prose (Alpha JWC = Indonesia VC → Portland-OR company memo gained Indonesia/rupiah risks); citation-enrichment fabricates example.com URLs even in codified-source mode — codified Sources.md only constrains the upstream researcher, not the downstream enricher. Cross-references [[crawl-fetch-ingest]] for portfolio/team data, [[sources-md-curation]] for the Sources.md file mechanics, and the open issues in context-v/issue-resolution/ ([[Limiting-or-Omitting-Investor-Judgement]], [[Competitive-Research-Generated-But-Not-In-Prose]], [[Including-Comparable-Exits-Valuations-IPOs]]) for known failure modes the new firm's first run will hit.
explorations/74
Create Study Everything as Code
Study Kickoff — Content Authoring Tools
MemoPop as a Claude Connector
Clients won't open our app. They'll ask Claude, and Claude will reach their deals, sources, and memo history through a connector.
A Syncbox for Client Document Folders — Where Does History Actually Live?
The ask is one product. The prior art says it's three layers, and nothing on the shelf does all three on a bucket.
Context-V as a Portable Plugin Any Agent Can Install
A human pastes one line, and their agent does the rest. The last mile of the cv plugin is an install contract written for agents, with Claude Code as the first harness, not the only one.
The MVP Delta, and What 'A Version Per Audience' Actually Requires
The editor half of the MVP is mostly built. The half that is the product, one document published to several audiences with proof that nothing leaked, has no code yet, two underspecified mechanisms, and one syntax in the spec that does not parse.
Explore Collaborator Codebases for Insights — Comparative Highlights
When a friend has built their own agentic-coding silo next to ours, compare the silos both ways: what we can learn from them, and what they can learn from us.
The Gap Between What We Preach and What We Practiced
Forty deployable units, one git repo, zero component-level design systems or changelogs. An honest audit of augment-it against the three recommendations we make to clients.
didi.sh — One Login, One Agent, Three Services
memos, decks, and augment-it become one family coordinated by exactly two shared planes: a common identity service and one agent named didi. Consumer one is live; the local-auth question is now closed.
Context-V as a Claude Code Plugin
The conventions are good and the agent still forgets them. A plugin turns context-v's workflows into commands and its frontmatter into queries — so a loop's preconditions get checked instead of remembered.
When Claud Code and When Pi
Grill Me: A Per-Section User-Input Moment in MemoPop Runs
A pause-point where MemoPop grills the user — the competitive section's synthesis frame is a judgment the model shouldn't make alone.
Deck Collections — a menu/aggregation layer above single-deck convergence
Everything dididecks has built so far (calmstorm, chroma) operates inside ONE deck: converging on a single narrative through variants and versions. reach-edu-hub needs the layer above that — a curated menu of several DISTINCT decks, each its own narrative (a 'strategy'). This doc names that layer 'deck collections', fixes the conceptual model (a collection groups peer decks; a variant is an alternate design of the same deck — different axis entirely), specifies the near-term reach instantiation (a Strategies collection of ~5, possibly more, decks), codifies the per-deck authoring loop (LLM-authored narrative markdown → Claude designs the deck Scroll-UI-first → register → drop into the existing dididecks variant/version workflow only if needed), and proposes how the concept graduates into the shared @dididecks/shell so it's reusable across client-sites.
Exporting the Strategy Decks to Google Slides
The seven strategy decks live as code — Astro Scroll-UI sections, not slides in any format Google Slides understands. Getting them into Slides for a stakeholder who wants to open, present, or lightly edit them in the tool she already knows is a real pipeline question, not a five-minute export. This names the actual path: what format has to exist first, what's proven prior art from calmstorm-decks, and what reach-edu-hub is missing today to make it clean.
What Corpora-Builder Needs From didi.sh — the primitives list, handed over early
corpora-builder wants workspace identity from didi.sh. Two gaps: workspaces aren't a thing here yet, and a CLI has nowhere to put a cookie.
Curating Only Valid Sources Across Runs
Downstream curation cannot fix what `citation_enrichment.py` invents upstream — 65 fabricated `example.com` URLs in a single run.
Design Language Audit — July 2026
The hand-counted baseline audit that measured the state of augment-it's CSS before the design system shipped. Superseded as the counting mechanism by design-drift.mjs.
Secrets for Collaborators Who Will Never Open a Terminal
Collaborators who will never open a terminal still carry API keys — so serve capabilities from a remote MCP plane, secrets held server-side.
Serving Secrets Server-Side as an MCP Capability Plane
Implementation-local notes on a remote MCP endpoint that holds credentials server-side and hands collaborators capabilities, not secrets.
Augment from DB — the org-first workbench flow, and the two new microfrontends it needs
A flow that starts from SurrealDB, not a CSV: pick an org, reveal its people and pulse streams, augment through pluggable search packs.
augment-it has outgrown one flow — ROTATION is the CSV-augmentation pipeline's shape wearing a general-purpose name, and corpora-curator's promotion to its head is a splice, not a fit
ROTATION (`shell/src/remotes.ts`) is the CSV-augmentation flow hardcoded as THE nav — every other use case gets spliced onto it.
Corpora-Builder System Design
Corpus building has been rebuilt as a sub-feature three times across ai-labs. This exploration surveys what those iterations actually taught us, and sketches the system that deserves its own repo.
Design Front-Loading and the Fable Build Loop
If frontier models can now carry complex builds end-to-end, the leverage moves to the documents. Can we front-load design so hard that the whole system gets built in a TDD loop — and impose design-system discipline from commit one?
Syncthing for Collaborator Access to the Corpus (R2 Backup Already Decided)
R2 already won the backup leg — rclone, not a live mount. This is the separate, still-open question: could Syncthing give other humans live access to the same corpus, without breaking the single-writer discipline that's kept things sane so far?
Cross-Product Native Agent Shell — Synthesis and Architecture Decision
Resolves the fork the in-app-agent docs left open — extend memopop-native or build standalone — against sixteen pinned repos' actual source.
In-App Agent Chat — As-Built vs. As-Specced (Internal Audit)
`@lossless/in-app-agent` was never built — augment-it inlined the WorkspaceAdapter pattern into `@augment-it/workspace` instead.
Shared Auth for Applied AI Labs
Three sibling apps need login; none is at Auth0/Clerk scale. A small owned system: OAuth, invites, org-scoped roles, a roll-up seam.
Two Clients, One Flow — Corpora by Domain-Type, Auth, and Deployment Converge
reach-edu wants corpus→memos by strategy, humain-vc by thesis — and typed domains, shared auth, and deployment all came due at once.
Corpus-Grounded Generation — Memory & Graph Layers for Producing Decks and Memos Without Drift
A pipeline where every factual sentence in a deck or memo traces to a source span — and the model abstains when it can't.
The Moat Is Grounded Deliverable Production, Not Chat
Chat-over-documents is commoditizing; the moat is the last mile — a shippable deck or memo with every claim traceable to source.
Funder-Fit Engine — Org-Anchored Corpora and the Bidirectional Story↔Funder Cycle
Fundraising matches both ways — funder→story and story→funder — on one org-anchored corpus. The differentiator is KAG, not plain RAG.
Forced One-By-One Tag Selector — a pulse-dimension pattern for deliberate triage instead of lazy bulk-tick
Bulk checkboxes produce uniform half-considered tags. Present one tag at a time — apply / skip / skip-rest — and each decision gets made.
Joined People UI and the Network-First Pivot — augment-it's sibling-flow to org-first augmentation, and the canonical/proprietary layer split underneath it
Org-first and people-first are two pivots on one join — and the split that matters is canonical (shareable) vs proprietary (client-only).
Best Way to RAG Over the Corpus — design space for retrieval-augmented operations on augment-it's per-client corpus, given the structured frontmatter we just earned
245 corpus files carry `funder_slug` and `published_at`, so retrieval is facet-filter-first — embeddings handle the residual about-ness.
Inbox Sort by Agent Tasks — moving the inbox from a flat 86-item pending queue into a task-typed work surface where the operator sees what's next and the agent does the safe parts automatically
86 pending inbox files render identically, so the operator context-switches between four task types on every scroll.
Operator-built flows beyond the universal pipeline — the default augmentation path is a dud for most edge cases, and the cheaper-than-microfrontend escape is a view-spec the agent-chat composes from natural language and the UI renders generically
The default flow lands cleanly on 17 of 96 reach-edu records. The escape isn't a microfrontend per scenario — it's a generic spec-renderer.
In-App Browser vs Browser Plugin for Corpus Add — bridging the operator's own search into the per-record corpus without leaving the cockpit
Adding one operator-found URL to a funder's corpus is a ten-step round-trip out to Google and back. In-app browser, or browser plugin?
Cloud Variant of the Dididecks-AI Workspace — Recreating Local Privacy When the Filesystem Isn't Yours
Clients who won't install a desktop app still need the privacy local-fs gives for free. What a cloud runtime would have to do explicitly.
Per-Client Privacy and the Path Off Local — when does single-operator-local-only stop scaling, what stack do we reach for, and how do we architect today so the move is cheap when it comes
Per-client corpus privacy and a client wanting login hit the same week. Not a stack decision — which choices keep the move off local cheap.
Agent-Chat Skills and Commands — Candidates List
The chat's verb roster is four prompt-focused capabilities. A running list of shell scripts that should graduate into chat-callable verbs.
Augment-It Prior Art Survey — What's Already Been Built, and What It Tells Us
Two prior attempts exist — Tanuj's three federated repos and Michael's bolt monolith. Both cover the core; neither is what we ship.
Bolt-Era API Provider Widget Analysis
The bolt widget picked Claude, GPT, or Perplexity per prompt section. The widget dies in the rewrite; the multi-provider shape stays.
Bolt-Era Codebase Analysis
A faithful architectural map of the bolt monolith — React + TS + Vite + Supabase + zustand — lifted from its own `specs/` folder.
Bolt-Era Highlight Collector Analysis
The only existing description of the highlight-collector stage — one of two that never got split into Tanuj's microfrontend repos.
Bolt-Era Main Container UI Analysis
The bolt shell's five-column layout and auth gate — prior art for the rewrite's open question: one host shell, or a host per app?
Bolt Monolith As Built — The archive/bolt-code Branch
The earliest augment-it is a Vite + React monolith on `archive/bolt-code`: feature-richer than the federated repos, architecture we discard.
Bolt-Era Prompt Section Analysis
Prompt templates as MDX-rich, variable-aware, edit-toggle-preview blocks — the pattern prompt-template-manager should probably adopt.
Bolt-Era Record Collector Analysis
Cross-reference against `Tanuj-Record-Collector-As-Built` — the diff between bolt-era and forked shows which patterns survived federation.
Entity-Profile Augmentation Workflow — Common Social + Vertical-Specific Sources, Per Entity Type
Two tiers replace prompt-by-prompt column filling: packs as atomic source-bound units, bundles as workflow-shaped compositions of packs.
Federation and Bundler Decision — Bun + Rsbuild + Module Federation, Workspace State, Optional Chat
We federate: Module Federation on rsbuild, bun over turbo, and state of truth in `@augment-it/workspace` — chat is just one consumer.
Tanuj's Prompt-Manager As Built
Full CRUD-shaped prompt UI over a hardcoded `samplePrompts` array — no store, no data flow. Keep the schema, throw away the implementation.
Tanuj's Record-Collector As Built
The most-finished of Tanuj's three splits. One idea survives: the prompt template auto-generates from the imported CSV's columns.
Tanuj's Request-Reviewer As Built — The Module Federation Proof
The only place Tanuj got federation working — a shared `RecordCard` — while the augmentation logic sits copy-pasted from record-collector.
Human-Curated Source Sets and Per-Firm RAG for Memo Narrative
Keep Perplexity's take as quarantined commentary and route real research through validated harvesters plus a per-firm standing RAG store.
Memory Layers for the In-App Chat Package
Maps the eight pinned memory systems onto roles in the chat package, and picks the v1 stack given we already lean on Chroma.
Remote Mount Contract for @lossless/in-app-agent — How the Chat Surface Drives Federated Views Without Owning State
How the chat surface drives federated views without owning state: capability invocation goes through the per-app workspace, never the chat.
Multi-Agent Research Fan-Out Per Row — The Real Shape of Augment-It's Capability Runtime
Capabilities aren't LLM calls — five research agents run per row in parallel, so the runtime needs (rows × agents) fan-out.
In-App Chat as the Agent Surface for Client Apps
Rather than design a button for every client request, wire one chat surface loaded with our patterns and context. The chat is the menu.
Separating Retrieval from Generation in Agent Pipelines
An agent that both searches the web and writes the prose fabricates URLs — 65 `example.com` links in a single memo run.
ChromaDB as Context Improvement Across Everything, Everyone
A founding-team demo reframed Chroma: not a place to put embeddings, but an ingestion layer for agent traces and session transcripts.
Collate Context Files into Context Vigilance as Repo & Project
A long-running, everywhere-distributed practice — context-v/ across a tree of pseudomonorepos — finally graduates into a project of its own, with a collator, a splash, and a vector index.
Crawl for Better Team Structured Output
The orchestrator writes prose about teams but never returns the structured roster the app needs to render cards: names, titles, photo URLs.
Moving an Agent Orchestrator to an API
The orchestrator is a Python CLI today. To plug it into memopop-native, we need an HTTP-shaped surface. Three options, ranked by effort and time-to-value.
ai-labs/explorations
augment-it/explorations
context-vigilance-kit/explorations
corpora-builder/explorations
dididecks-ai/explorations
flave-ai/explorations
id-didi-sh/explorations
memopop-ai/explorations
memopop-orchestrator/explorations
reach-edu-hub/explorations
studies/explorations
issues/71
Claude connectors need didi.sh to be an OAuth server
didi.sh knows who a person is. It can't yet tell Claude so, and MemoPop's connector is the first product waiting on that.
Splash rollup:sync fails from where the operator actually stands
`pnpm rollup:sync` errored at the ai-labs root (no such script) and inside splash/ (pnpm 12 ignored the build allowlist). Both fixed.
A component test whose fixture is simpler than its call sites
Selector--Menu's suite was green while both of its first two adopters were broken in exactly the way its header promises to prevent.
A silently ignored alias pointed a verification probe at production
rsbuild accepts source.alias and ignores it. Three agents rendered live data believing it was a fixture; one wrote a file into client corpus.
Issues raised by the migration subagent while converging request-reviewer
Findings surfaced while doing something else. Raised, not chased — the diff stays clean and the finding stays reviewable.
Structural invariants live in prose, so sweeps stop halfway and nothing notices
Three units have now been found whose typecheck had never once passed. Each was found by accident, five weeks apart, by someone tidying something else.
The federation has no layout layer, so seven of its eight deviations are about placement
The design system standardised everything that goes inside a box and nothing about the boxes. Consumers keep their freedom for now — deliberately, and on the record.
Need an Elegant Resolution to Source Pointers vs. Master
One source, many folders, is the design. But for 75 sources the body sits in an untriaged inbox file the scoped read never reaches.
24 Orphaned bin/ Objects From a Half-Migration
A test that checked the object existed but never the pointer. Ghostscript's nondeterminism turned a sequencing mistake into 24 untraceable objects.
Every remote hardcodes the workspace WebSocket to localhost — Org Workbench loads no data on augment.didi.sh
Sixteen remotes dial `ws://localhost:3001/ws` with no env read. On prod that points at the visitor's own laptop, so the socket shows `closed` and the roster never fills.
Tokens landed, components didn't — the UI needs an overhaul, and the drift linter can't see the problem
19 of 20 apps consume the theme package; shared-ui ships exactly two components. Every remote hand-rolls its own buttons, pills, and empty states against shared colours.
The lfm barrel imports node builtins, so it cannot be bundled for a browser
A consumer that only wants `parseMarkdown` still drags `node:crypto`, `node:fs` and `node:path` into the bundle, because the main entry re-exports OGCache. Same class of defect lfm already documented for plantuml — but in the front door.
A failed deploy is silent, so nothing watches production after merge
Every frontend Docker build failed for twelve days unnoticed: the old container keeps serving and the health check keeps passing.
Domain type is ambient state, so a failed workspace load hides every corpus
humain-vc opened the Corpora Curator and saw 'strategy' and 'No corpora yet' — it has theses, and plenty of them. One guessed value at load time silently filtered the whole surface, and the same symptom was debugged out once already on 2026-07-07.
One stuck message kills a NATS subject until restart — `domain.list: timeout` and the sequential handler loop
Every handler in `domains.ts` consumes its subject with a `for await` loop, so one unsettled request blocks the subject until a restart.
Move the rest of the app to remote hosting — prod still falls back to localhost for every undeployed remote
12 micro-frontends are hardcoded to `http://localhost:3XXX` in the prod shell, so augment.didi.sh fetches them from the visitor's machine.
Concurrent agent searches queue into a search-results column — fire many, deal with them as they come
Agent searches run 60–210s and each one hijacks a single column. Wanted: a rightmost queue where every fired search appends its own card.
Fetch full content clobbers the operator's metadata — resets the title to a URL approximation
`fetchSourceContent` never consulted the saved title, so Jina's guess — or the raw URL on failure — overwrote what the operator typed.
Jina metadata parser is blog-only — needs two profiles + fuzzy routing (academic sources lose their date/publisher)
The parser only reads OpenGraph keys, so scholarly sources lose date and publisher to `citation_*` / `dc.*` / `prism.*` it never looks at.
No test coverage — TDD keeps getting deferred, despite being exactly the right fit for agentic development
Agents rewrite this codebase with zero automated tests — and the iterate-until-green loop is exactly what agents are best at. Pick a runner.
Parent-Child Nested Organizations Are Not Modeled — Initiatives, Funds, and Sub-Orgs Have Nowhere Canonical to Hang
`upmobility-foundation-urban-institute` welds a parent org to its initiative, so triaged content has no honest folder to land in.
Refactoring for API Speed — a single-user app should boot in milliseconds, not a minute
Measured: shell mount to workspaces ready is ~543ms. The perceived minute was a stale deploy plus remotes hanging on `localhost:3XXX`.
Search & Add's invokes never reach the workspace — the pane hangs at 'searching…' while every backend rung is green
SearXNG answers, `search.fire` answers, the org card loads — yet the 🔍 pane hangs forever. The frame dies inside the client transport.
Session expiry turns the app into a zombie — the 12h JWT dies mid-use, the UI stays up, and every invoke times out
The `didi_session` cookie lives 30 days, the JWT inside ~12h, and nothing calls `/api/session/refresh` — the transport 4401-loops at 2/sec.
Tag input swallows commas into one mega-tag — commas should split into separate tags
`toDashed` splits on every non-alphanumeric, so commas behave like spaces and three intended tags fuse into one mega-tag.
Troubleshooting workspace ↔ DB state alignment — humain-vc's corpora don't load, and the canonical layer holds fewer than the operator created
The humain-vc workspace renders empty-or-wrong corpora while the canonical layer itself holds fewer humain-vc domains than the operator remembers creating — four suspects, each with a discriminating signature.
Workspace + corpora connection is slow-to-hanging, and the auth token won't persist
The Corpora Curator sits at 'connecting…' and the workspace switcher at 'loading…' — corpora never arrive — while the didi session drops within a minute of signing in, forcing a re-login. Two symptoms that most likely share one root cause.
Funder↔strategy is tags for now — whether it deserves a real edge is deferred
140 strategy tags landed on 69 funders, but a tag can't carry evidence counts, gift sizes, or recency. The edge question comes due later.
Header polish — the FLOW label and shell suffix have outlived their jobs, and the chat toggle sits on the wrong side
Four findings from the first production walk-through — including a chat toggle on the right that opens a rail pinned to the left.
Relation kinds are inverse pairs — one stored string can't speak from both seats
NextLadder is funded_by Ballmer Group; Ballmer Group is funder_of NextLadder — the same edge needs a different kind string per perspective, and today only one pair is special-cased in a read-time map.
Capability Gaps Surfaced by the First Triage Co-Pilot Run — One Collective Ledger, Not Five Tickets
Five gaps from the first triage run — including direct SurrealDB writes whose string-typed ids silently failed to join their org rows.
State-Inspector as a universal need — every ai-labs app hides its state from the people running it
No ai-labs app can answer "what does it currently believe?" — rune singletons, deck state, LangGraph FlowState, none inspectable.
Corpus adds don't fetch metadata — and the row gives no cue either way, and there's no inspector to see or fix it
`organization.corpus.add` writes url, kind, and domain then stops — the Jina metadata fetch never fires, and nothing on the row says so.
Corpus items aren't visible on person cards — and corpus coverage across entities is hard to assess anywhere
The person card says 'Corpus items 3' and shows nothing — the operator can add a fourth without ever seeing the three that exist.
Crawl progress is a black box — 'crawling the web, this takes a minute…' needs traces the operator can watch
The model narrates as it crawls — `extractText` skips straight past it to the final answer, so the operator gets a minute of ellipsis.
Crawl replies can be lost — the eternal 'crawling…' spinner (no client timeout, reconnect-dropped invokes, tight dispatch ceiling)
The Curry Foundation crawl finished in 87s and the tab spun forever: no client deadline, reconnect-dropped invokes, a 300s ceiling.
The crawl's search substrate is fixed to Anthropic web search — the operator expected to choose
The manual 🔍 has a provider palette; `organization.crawl` is hardwired to Anthropic's server-side web_search with no dial and no label.
Switching flows from the Flows popdown doesn't surface the new flow's stage — a rotation-step click is required
Switching flows flips the pill but leaves the stage blank until a step-bubble click. Only tabs with persisted layout state reproduce it.
Invokes survive reconnects — the claim protocol closes the eternal-spinner root cause
Two crawls finished server-side while the tab spun forever. Pending invokes now survive a socket drop and re-attach by id via claim frames.
List rows show hostname only — the path is hidden, so same-domain entries are indistinguishable
`AdditiveList`'s `host()` drops the pathname, so two Gates Foundation links both render as `gatesfoundation.org` and can't be told apart.
Live/not-live indicator tooling — parts of the UI feel dead, and there's no single view that says whether everything is actually working
Five distinct failures — dead remote, dead socket, dead service, no refresh, unwired button — all present to the operator as one dead click.
Merging organizations or people — when two objects turn out to be the same entity, dedupe non-destructively
Two rows are sometimes the same entity and nothing merges them — no edge re-pointing, no list union, no slug absorbed into `aliases[]`.
No component library — the UI is improvised per-remote instead of component-based, and it's starting to show
Fourteen remotes improvised their own UI, so status pills and candidate pickers now exist in parallel dialects. The bill is arriving.
No user visibility into state — the app needs a State-Inspector surface
State lives in five places and none are inspectable from inside the app — nothing shows which remote currently believes what.
Org Workbench in a narrow pane — the roster doesn't collapse, and the org card's contents spill out of their container
In a narrow pane the roster keeps its 300px and the card's link rows overflow — the flexbox `min-width: auto` trap, twice.
The Org Workbench can't create an organization — and creation must sit behind a 'be sure there is no match' gate
The workbench can only find orgs that exist. Creation must sit behind the same show-every-match gate that already governs adding a person.
A person's bio page on another org's site is an affiliation signal, not just an identity link — the UI should offer the promotion
A bio on another org's domain is three facts — identity link, affiliation evidence, observation. The card captures one and drops two.
Pulse streams need an editable kind and a user-facing name — 'Today's Credentials' is not an 'updates_index'
The operator can neither fix a stream's inferred kind nor record its name — `media_streams[]` has no title field for Today's Credentials.
The search column holds stale results — a new agent search doesn't reload it
The team crawl bypasses the Search & Add envelope, so the column sits frozen on the last search's candidates, masquerading as current.
Team-crawl accept drops the crawled links and leaves the staged row — double-save risk
`person.apply` writes `linkedin_profile_url` as a scalar only, so accept discards the crawl's links — and the staged row lingers.
Search Providers as First-Class — Stand Up SearXNG as the New Default for Social Packs; Tavily Stays as a Peer; Per-Row Iteration as the Workflow We're Building Toward
Tavily is a content-RAG index — wrong substrate for social-profile pages. The fix isn't a swap — it's making provider plural per-fire.
Issue: How People, Organizations, and Their Relationships Actually Enter SurrealDB
Not a bug — a verified trace of the canonical write path, because the DB already does more than the UI or the operator's memory shows.
Issue: Person · DB Resolver UI needs to accommodate multiple organizations per person
`person-db-resolver` resolves one org per row, but Lincoln Ellis's bio names four — no way to add an Nth without re-running the row.
The Drag in AI-Assisted Web Research — Diagnosis, Prior Art, and the Open Forks for a Source Curation Gate
AI research yields enough hallucinated sources that manual Google + Docs looks time-competitive. The drag is structural, not a prompt bug.
Grilling on the DB Resolver — questions to settle before v0.0.0.2 / v0.0.0.3
Three decisions before v0.0.0.2: where the join key lives, whether a slug can be renamed safely, and whether opportunities reopens Decile.
Personal-link observations need named query lenses — without them, an accumulating fact log goes uninspected
`has_personal_link` observations carry rich qualifiers and no queries. One thought leader can contribute 50+ before anyone can look.
Some records show empty corpus in the Sort & Filter Lens despite per-funder directories existing on disk — the lineage join is healthy but the workspace-service capability has no timeout override (defaults to 5000ms), the content-ingest handler processes requests serially, and each call walks every funder directory under clients/<id>/corpus/, so late requests in the 96-row fan-out time out and the lens swallows the error silently; the durable fix is to make corpus_funder_slug (a column the records sheet already populates) the primary join key, which limits each call to one small directory and dissolves the timeout race — this supersedes the originally-proposed corpus-overrides.yaml because the override surface is now the records-sheet cell
No `CAPABILITY_TIMEOUTS_MS` entry for `corpus.list_for_record` — 96 parallel calls hit the 5000ms default and the lens swallows the error.
Funder Corpus First Session Failed — 75 markdown files across 15 of 96 funders, 81 records unprocessable, hours spent layering filters on stale data instead of producing clean fresh data, rebuild against the goals spec exists in code but was never validated against a real pack fire because the session ended
Six hours produced 75 corpus files across 15 of 96 funders — 81 records still have nothing. This is the failure-mode list for morning-self.
OfficialPulse URLs Appear as Junk in Promoted Versions — operator believes promote v6 → v7 → v8 wrote bad data into the array column; audit shows promote is clean and v6 itself already contained every URL
Promote added nothing — v5 through v8 carry identical 122-URL arrays. The new renderer just made them visible, and no UI can remove one.
Augment Transformations Not Reliably Persisting — Hand-Curated Field Edits and Whole-Row Augmentations Are Disappearing Across Record-Set Versions
98 hand-curated URLs across 45 records with no save or promote affordance — only the row-store's auto-persisted JSON keeps them alive.
Troubleshooting UI for Official Blogs — The Bundle Fire Path Doesn't Fit the Flow That Was Built for Prompt Templates
Bundles fire end-to-end, but the Flow assumes every fire routes through a prompt template — so every step past 2 is wrong for a bundle.
Changelog entries duplicated across augment-it/changelog/ and content/changelog--laerdal/
Eleven backfilled augment-it changelog entries currently live in two places. Either location can be the source of truth — but right now both are, and updates have to be made twice.
ai-labs/issues
augment-it/issues
context-vigilance-kit/issues
corpora-builder/issues
flave-ai/issues
id-didi-sh/issues
memopop-ai/issues
memopop-native/issues
memopop-orchestrator/issues
loops/18
Run the Connector Plans with a VP Eng and Subagents
One VP Eng holds the spec and the ledger; engineer subagents each take a plan from failing tests to green, changelog, and push.
Adopt Selector in one member
The test comes before the refactor. This is the first organ whose defects are invisible — a broken keyboard renders perfectly.
Adopt CardRow and a SelectWrapper in one member
The pilot executor. Three members answer the open decisions with evidence; everything mechanical is inherited from the Button loop.
Adopt the shared Button in one member — the per-member executor for the Button rollout
One member per run, never a sweep. Replace the buttons, delete the recipes they made redundant, raise everything else.
Adopt the shared Chip in one member
The per-member executor for the Chip rollout. Inherits every probe and verification rule from the Button loop; what differs is the judgement about what a chip even is.
Converge the federated design system — scan members for organs, fingerprint them, and triage divergence into five verdicts
Creativity is the default and stays the default. The loop's job is to notice when two teams solved the same problem twice without meaning to.
Endow a Component With Its Own Contracts
The repeatable procedure for giving one unit — service, remote, package, or shell — the four firsts it owes. One unit per run, never a sweep.
Spec to Shipped with TDD — the two-role loop that runs unattended
A two-role loop — PM enumerates the tests, engineer implements to green — with status derived by running the suite, never asserted in prose.
From a Raised Issue to Fixed-and-Shipped — the bug-to-ship loop
A raised issue becomes a context-v issue doc, a gh issue, then an attempt→verify cycle that safety-commits every failed try and milestone-commits the win — closing with a changelog beat and an offer to bump semver + tag.
Sweep — Local & Federated Design System for Fidelity
The repeatable procedure for checking a member's CSS against the federal contract. The one sanctioned exception to the two-file rule.
Implement-Feature Loop — plan → gh tickets → code/verify/changelog/commit per ticket → human browser test → ship
The generic feature-execution cadence: a signed-off plan becomes gh tickets, each ticket lands as verified code + a changelog beat + a conventions-clean commit, and the run closes with a human browser test and a ship() commit.
Loop through a spec — write the plan, implement, test, changelog, commit, repeat until Shipped
The phase loop that took Augment-From-DB-Flow from Signed-Off to Shipped in one day: plan, implement, prove, changelog, commit — per phase.
augment-it/loops
corpora-builder/loops
dididecks-ai/loops
id-didi-sh/loops
memopop-ai/loops
memopop-orchestrator/loops
handoffs/5
Handoff — the delta to MVP, 2026-10-03
Read this first if you're picking up flave. The editor works. The part that is the product, one document published to several audiences with proof nothing leaked, has no code yet. Here is that work, in order, with the decisions that gate it.
augment-it/handoffs
flave-ai/handoffs
memopop-ai/handoffs
memopop-orchestrator/handoffs
decisions/13
Host the Connector on Railway at memopop.didi.sh
The connector gets its own subdomain pointed straight at Railway. No domain to buy, and no proxy in front of streaming.
jj Versions Text, and a Save Snapshots to the Bucket
Every draft is versioned without the client touching version control, and a single save backs the whole workspace up.
No Tool Ships Without Its Docs and Tests
MemoPop's connector is our first API, so it sets the habit: every tool has docs written for agents, CI tests, and a live health check.
One Workspace per Firm, with a Private Bucket
Each client firm gets one workspace on our server holding all its deals, plus a private bucket of its own for originals and backups.
Sign In Through didi.sh OAuth
Partners sign in once with their didi.sh account, and the token says which firm they belong to. didi.sh has to grow OAuth first.
The Client's Claude Does the Work
In v1 we pay for almost no model calls. The partner's own Claude writes the memo; MemoPop supplies the method and keeps the work.
The Server Hands Claude the Method One Step at a Time
Claude never holds the whole pipeline. It asks for the next step, does it, hands back the artifact, and asks again.
Three Kinds of Error, and Optional Steps Never Block
A blocked memo is the worst outcome. Every error says whether MemoPop is down, the request is wrong, or the step can be skipped.
Context-V Is an OKF Profile
Any tool that reads Open Knowledge Format can read a context-v folder. The price is one frontmatter field and an index file.
The list-surface paradigm — CardRow, ListContainer, and where selection lives
Sixteen of eighteen members are the same shape: controls up top, a generated list below. Five decisions are open; the BEM rollup makes most of them reversible.
augment-it/decisions
context-vigilance-kit/decisions
memopop-ai/decisions
contracts/2
profiles/69
Agent-Native — Profile
The chat isn't bolted onto the app. The app's operations are one action registry that the UI, the agent, MCP, A2A and the CLI all call, and the conversation is just one more caller.
Automerge — Profile
The only entry where two people editing the same paragraph is a solved case rather than a second file with a longer name — and it costs you the filesystem.
git-annex — Profile
Content is optional. git tracks which copies exist where, and refuses to drop the last one — the bookkeeping that makes deleting a local file safe.
Jujutsu (`jj`) — Profile
The storage layer is five pluggable backends, not one — and only two of the five have a shipped implementation you could put in a bucket.
Kopia — Profile
Its snapshot manifest has the free-text Description field restic lacks, and its policies attach per directory and inherit — the ask's own shape, in the store.
Rclone UI — Profile
The only entry that solves the trigger problem — 5,167 lines of Rust registering jobs with launchd, crontab, and Task Scheduler behind one trait.
restic — Profile
Its on-disk layout is data/<ab>/<sha256> plus snapshots/<id> — which is corpora-builder's unbuilt Phase 4, already shipped and hardened since 2014.
Seafile — Profile
Git's object model with content-defined chunking underneath and a human-readable description on every commit — and the S3 backend is the paid tier.
Syncthing — Profile
Closes a question two Lossless docs left open: a receive-only device does not silently orphan the collaborator's edit — it flags it, counts it, and offers Revert.
12-Factor Agents — Profile
Nothing to install — thirteen essays whose answer to "who owns the prompts, the context, the state, the control flow?" is always *you*.
5ire — Profile
5ire's MCP layer has no apply button — editing a server row in PGlite makes the client reconnect via the live-query changefeed.
Agent2Agent (A2A) Protocol — Profile
The load-bearing commitment isn't the JSON-RPC — it's *opacity*. An A2A agent publishes skills, never its prompts, memory, or tools.
AGENTS.md — Profile
The entire specification is one precedence rule: the closest `AGENTS.md` to the edited file wins. No schema, no validator.
Aider — Profile
Aider has no tool-call loop and no MCP client — not a thin one, none at all. It reads diffs straight out of plain chat text.
AnythingLLM — Profile
A "workspace" is a config row over one always-shared backend: the chat provider varies per workspace, the vector DB never can.
AutoGen — Profile
Every AutoGen team type overrides exactly one method — `select_speaker()` — and that single seam is the whole difference between them.
Beads — Profile
Not one embedding anywhere in the recall path — retrieval is a SQL view and a graph walk over the agent's own work graph.
ByteRover CLI — Profile
The memory store is a directory of Markdown you can cat, grep, and diff, with its own git history. Recall is BM25, not embeddings.
Chroma — Profile
The hybrid retrieval in Chroma's docs raises `NotImplementedError` on a laptop — `Collection.search()` is gated behind Cloud.
Cline — Profile
"Memory Bank", the cross-session memory pattern Cline is best known for, has zero lines of code behind it.
Codex — Profile
Codex compiles a real Apple Seatbelt profile and Landlock ruleset: a fully autonomous session that never prompts is still jailed by the OS.
Continue — Profile
Five differently-scoped assistants can ship side by side in one project and swap mid-session — hot-swapping a skillset per project.
Delta-Mem — Profile
Memory as a dense rank-8 state matrix inside each attention head, updated token by token — the model never looks anything up.
Dive — Profile
Two native shells, neither containing a line of agent logic — both are thin supervisors spawning the same Python subprocess.
Frictionless Specs — Profile
This one specs *datasets*: every RFC 2119 "MUST" in the prose maps onto a constraint in a published JSON-Schema profile.
GSD (Get Shit Done) — Profile
GSD's wager is that the limiting factor is context rot, not spec rigor — so it ships no spec grammar and resets the window per task.
Goose — Profile
In Goose, "extension" just means "a live MCP client" — and two variants skip the subprocess entirely to run in-process.
Graphify — Profile
The whole memory layer is one in-process NetworkX graph and a `graph.json` you can copy around — no database anywhere.
Graphiti — Profile
`expired_at` is when the engine retired a fact; `invalid_at` is when it stopped being true in the world. Routinely different dates.
Hindsight — Profile
`fact_type` is a database CHECK constraint: world facts and first-person experiences travel through different extraction prompts.
Honcho — Profile
Collections are unique on (observer, observed, workspace) — Honcho indexes memory by relationship rather than by user.
Kaas — Profile
Every credential, provider quirk, and even context assembly lives in Rust; React gets typed `invoke()` calls and nothing else.
LanceDB — Profile
The database *is* the file format: a `.lance` directory DuckDB, Polars, and Pandas read with no LanceDB process running.
Letta — Profile
The one entry where the agent itself — not an extraction pipeline, not a background summarizer — is the memory manager.
llms.txt — Profile
The only behavioral semantic in the whole format is an H2 named `## Optional` — links there may be dropped when context is tight.
MCP-API — Profile
However many APIs a user registers, the model only ever sees two tools: `ListAvailableApis` and `CallApi`.
MCP Python SDK — Profile
The pinned checkout is the unstable half of a rework: v2 swaps `FastMCP`/`ClientSession` out for `MCPServer`/`Client`.
Mem0 — Profile
Despite the graph-memory marketing, the graph is an array of linked memory IDs hanging off spaCy-extracted entities.
MemPalace — Profile
The counter-bet: extract nothing. Raw 800-character chunks score 96.6% R@5 on LongMemEval at zero LLM calls.
Milvus — Profile
One Milvus deployment is not a process — it is nine roles, three external dependencies, and a C++ ANN core reached through cgo.
Model Context Protocol (MCP) — Profile
The three *client* primitives — Sampling, Roots, Elicitation — let a server use the host's model without ever getting the user's key.
Neo — Profile
Familiar high-confidence queries get dialled down to low reasoning effort — memory shows up as a smaller bill, not better accuracy.
OpenSpec — Profile
An LLM should never re-emit a whole spec to change one line, so changes ship as `ADDED` / `MODIFIED` / `REMOVED` deltas.
Open Vibe — Profile
One real OS child process per workspace — but only ever one binary. What varies per workspace is the invocation, not the backend.
OpenAgent — Profile
Delegation recursion is prevented not by a depth counter but by never registering `spawn_agent` on the child's tool server.
OpenCode — Profile
A terminal coding agent with 38 SQLite migrations and real OTLP tracing — built like a production SaaS backend, and no Go anywhere.
OpenHands — Profile
Pin `OpenHands/OpenHands` today and you do not get the agent — the CodeAct loop moved out to a versioned pip dependency.
OpenUI — Profile
JSON spends ~30% of its bytes on punctuation an LLM has no reason to emit; the same seven UIs cost 47–67% fewer tokens in OpenUI Lang.
OpenViking — Profile
Memories, resources, and skills collapse into one `viking://` tree, and retrieval is a recursive directory walk, not a vector query.
Paxm — Profile
Paxm is not a memory store — it is routing and durability in front of seven-plus pluggable backends, and it does zero semantic dedup.
pgvector — Profile
About 3k lines of substantive C, and it inherits MVCC, WAL, replication, PITR, and row-level security completely untouched.
Pi — Profile
Pi's docs refuse MCP, sub-agents, permission popups, and plan mode by name — then ship every one as a first-party example extension.
Qdrant — Profile
Qdrant estimates a filter's cardinality *before* searching, which is why recall doesn't collapse the moment you filter on `tenant_id`.
RetainDB — Profile
Supersession as an actual indexed column — `validUntil`, `supersededBy` — rather than something the ranker is hoped to handle.
Routa — Profile
The swappable unit turns out to be the session, not the workspace: two sessions in one workspace can run two different agent CLIs.
Spec Kit — Profile
No plan gets past the Simplicity, Anti-Abstraction, and Integration-First gates without a written, paper-trailed exception.
StateBench — Profile
The trade nobody advertises: more context raises decision accuracy and superseded-fact resurrection together.
Supermemory — Profile
The most polished client surface in the study, wrapped around an engine that is not in the repo — every SDK points at a hosted API.
Superpowers — Profile
A SessionStart hook injects the bootstrap skill as `<EXTREMELY_IMPORTANT>` before the agent has written its first word.
Symphony — Profile
OpenAI shipped the spec, not the product: 2169 lines of RFC 2119 with sections *deliberately made redundant* for coding agents.
Understand-Anything — Profile
When an LLM authors your graph, the schema layer stops being a validator and becomes a repair shop — alias maps fold synonyms back.
Volt — Profile
Numeric thresholds decide when to compact, and the model is only ever asked to write summaries. Long-horizon coding as a DB problem.
Weaviate — Profile
The database itself calls OpenAI to embed on write and Cohere to rerank on read — the RAG pipeline lives inside the store, not the app.
agent-harnesses/profiles
conversational-ui-and-native-shells/profiles
memory-layers-for-agents/profiles
open-specs-and-standards/profiles
sync-and-content-version-control/profiles
vector-databases/profiles
narratives/27
Citation Registry for reach-edu-hub Narratives
One hex code per unique article, held once per client. Narratives cite [^abc123] inline; definitions resolve from here. Codes are minted once and never renumbered — reorder, split, or scramble content freely without breaking claim–source pairing.
Pitch Narrative — Agent Workflow Maxxing: Operate Like a Team Five Times Your Size
The internal pitch arc for the agent-workflow-maxxing strategy: the same catchy-line-plus-cited-numbers pattern as the funder decks, aimed at Reach/Lossless leadership. The case: a $25M campaign with an August 2026 anchor deadline and a funding landscape full of dated windows is exactly the workload a small team cannot cover manually — and agents are how it gets covered without abdicating judgment.
Agent Workflow Maxxing
A small team has the surface area of a big one — sales conversations, travel, conferences, grant pipelines, stakeholder relationships — and historically had to triage most of it away. Dedicated agents and agent workflows change the math twice over: they reduce overwhelm on the work you already do, and they make possible work that simply wasn't (outreach nine months ahead, ten sales conversations at once, a grant corpus that drafts itself). This is the operating strategy — where to point agents first across travel, events, grants, ABM, and social — with examples, tools (paid + open source), and the human-in-the-loop guardrails that keep it from backfiring.
Pitch Narrative — NCAD Forge: Charter the Lab
The pitch arc for the agentic product lab (corpus slug ncad-forge): the Apprenticeship Degree runs on a technology stack nobody built, the people who understand it can now prototype it themselves, and the AI-in-education funding wave of 2025–26 is looking for exactly this kind of shared infrastructure. What's next, with your gift: a chartered, shared lab at NCAD — domain experts prototyping, engineers hardening, the whole member network compounding.
NCAD Agentic Product Development Lab
Apprenticeship Degrees need a different technology stack than traditional or even online universities — one that integrates work and learning, gives employers visibility, and delivers chunked, assessable learning to busy working adults while still meeting credit-bearing accreditation. Historically that stack could only be built by expensive software-engineering teams. As of 2026, agentic 'vibe coding' tools let designers and domain experts prototype working software themselves. So the people closest to the problem — apprenticeship, industry-skills, and adult-education experts across NCAD's member network — can now prototype and build momentum on new pieces of that stack. This is the proposal to stand up that capability as a shared lab.
Pitch Narrative — Frontier Job Demand: The Job Is the Curriculum
The funder/employer-facing pitch arc for the frontier-job-demand strategy: course catalogs are lagging indicators, and the fields with the most unmet demand — advanced manufacturing, drones, applied AI — move faster than any curriculum committee. What's next, with your gift: the first apprenticeship degrees designed backward from frontier jobs, launched with the employers who are desperate for the talent.
Opinionated Program Design: Frontier Job Demand
Don't build apprenticeship-degree programs from a generic course catalog — design them opinionatedly toward where job demand is actually going. Three frontier fields have the rare combination of huge unmet demand, strong employer pull, and work that's perfect for a work-embedded degree: Advanced Manufacturing Operations, Drone Sciences, and AI Technology in Business Operations. The Apprenticeship Degree is uniquely suited to fast-moving fields where the job itself is the curriculum — and the outcomes (employment, wages) are already proven.
Pitch Narrative — Foundational Capabilities, Measured Improvements
The funder-facing pitch arc for the literacy-numeracy strategy: the labor market pays for the skill, not the diploma — and most working adults are below the line on exactly the skills that pay. K-12 already proved what works and how to measure it; postsecondary never tried, because the degree assumes. What's next, with your gift: foundational-skills instruction woven into work and sized for the moments working adults actually have, measured continuously by audio-based AI — the first university delivering measured improvements in foundational capabilities, shared onward through NCAD, and compounding into the next generation.
Improving Literacy & Numeracy in Working Adults
Literacy and numeracy independently predict wages and promotions — even controlling for degrees, experience, and demographics. Yet most working adults sit below proficiency, and a credential can be earned without the underlying basics improving. This strategy folds validated foundational-skills pedagogy (the science of reading, now reaching adult education, plus contextualized/embedded numeracy) into the Apprenticeship Degree, and *measures* the gain — so the degree doesn't just certify, it durably lifts the capability that the labor market actually pays for.
Pitch Narrative — Reverse Engineer Available Funding: Fish Where the Whales Are
The internal pitch arc for the reverse-engineer-funding strategy: funding is a power law, the campaign's own anchors prove the method, and the mega-gifts research just handed the team a reverse-engineered map of every whale in Reach's waters. What's next: point the team's scarce hours at capacity × alignment, and size every ask to the largest amount that fits the funder's pattern.
Reverse Engineer Available Funding
Grant funding follows a power law: a small number of mega-foundations move most of the dollars, and a fast-growing population of ultra-wealthy individuals — especially 'new money' — hold enormous discretionary giving capacity. So don't spray small applications across a long tail. Concentrate where the money is: study the biggest, most-aligned funders' public footprint, get an intro call to learn their actual strategy, pattern-match across their giving, and design the ask to hit the sweet spot for the largest plausible amount.
Pitch Narrative — Rural Income Boosts: The Raise That Stays
The funder-facing pitch arc for the rural-income strategy: rural America's bind is a loop — shortages, low incomes, brain drain — and the Apprenticeship Degree breaks it at the hinge point of income, in place. Arkansas already proved it with a ~2.4 effect size. What's next, with your gift: the Delta expansion at the exact moment Walton re-aimed its home-region strategy at the same map.
Rural Income Boosts through Apprenticeship Degrees
A strategic narrative: the Apprenticeship Degree is not only a teacher-pipeline fix — it is a rural economic-development engine. Because it starts with a paid job and ends with a better one, debt-free and work-embedded, it raises individual incomes in place, keeps talent (and its wages) local instead of exporting it, and compounds into a local-economy multiplier — exactly what rural communities facing workforce shortages and out-migration need.
Pitch Narrative — Upward Mobility: The Mobility Engine
The funder-facing pitch arc for the upward-mobility strategy: what's next, what could be — with your philanthropic gift. Builds on the CEO's June 2026 campaign deck ('what is') and extends it with the mobility evidence base and the funding-flows landscape. Catchy line per beat, KPIs underneath, every number cited by hex code.
Upward Mobility: The Apprenticeship Degree as a Mobility Engine
A strategic narrative: follow one person's trajectory, not a system or a region. For a first-generation working adult, the traditional mobility engine — go away to college — now carries debt risk, income disruption, and dropout risk that fall hardest on exactly the people who need the climb most. The Apprenticeship Degree re-engineers the engine: climb while working, without borrowing, without leaving. The evidence says the postsecondary degree is the single strongest predictor of lasting job quality, and philanthropy's biggest new pools — NextLadder, Blue Meridian, MacKenzie Scott's giving — are all organized around exactly this outcome: economic mobility.
Pitch Narrative — Workforce Development: Stop Training and Praying
The funder-facing pitch arc for the workforce-development strategy: the system trains and prays; the evidence says exactly what works; the Apprenticeship Degree is the only model that stacks every proven design feature — and the corporate-philanthropy wave of 2026 is funding everything around it except the degree itself. What's next, with your gift: the degree-bearing backbone of American workforce development.
Workforce Development: The System Is Broken. The Model Is Here.
The U.S. workforce development system was built around employer demand, not worker mobility — producing credentials without career ladders, training without guaranteed outcomes, and a 'train and pray' model that leaves millions sidelined. The evidence is now clear on what actually works: work-based learning with adult relationships produces job quality gains that persist a decade. The Apprenticeship Degree is the only model that stacks all the evidence-based design features at once — earn-while-learn, employer co-design, post-secondary credential, and measured outcomes — at the exact moment federal policy aligned behind scaling it.
Fundraising Story 01 — The Apprenticeship Degree Is a New Category
Reach didn't build a better program; it built a new category of higher education — the work-embedded, debt-free, employer-paid degree — and the field's biggest funders are converging on the idea right as Reach has the only proven national instance of it. Fund the category-definer.
Fundraising Story 02 — Teaching Already Proved It
Reach's apprenticeship degree isn't a pilot hoping to work; it already solved the teacher-shortage problem at scale — 420+ K-12 systems across 8+ states, debt-free, paid-while-you-learn. For education funders this is the rare 'fund the proven thing's next chapter' story.
Fundraising Story 03 — The Care-Economy Workforce Emergency
Behavioral health and healthcare have an acute, quantified workforce shortage and a talent pool 'hidden in plain sight' — incumbent care workers who can't reach licensure. Reach's Apprenticeship College of Health turns those jobs into degrees. This is the corpus's hottest, best-funded, most urgent story.
Fundraising Story 04 — Economic Mobility Without the Debt
Nearly every funder in the corpus shares one north star: economic mobility. Reach's distinct claim is that it delivers measurable earnings gains in the learner's own community with zero debt — arguably the highest-ROI mobility intervention a funder can buy. This is the macro story that unifies the portfolio.
Fundraising Story 05 — Workers, Not Employers: Fixing the Broken Talent Marketplace
The talent marketplace is broken — millions of open jobs, millions of underemployed degree-holders, and employers who can't retain. Reach flips the model: it credentials the workers an employer already has, so talent development becomes retention. This story speaks to the workforce-development and skills-based-hiring funders.
Fundraising Story 06 — Talent Hidden in Plain Sight: Place-Based & Rural Pipelines
Reach's degrees don't require leaving town — learners earn them in their home communities, in the jobs they already hold. That makes Reach the natural vehicle for place-based and rural funders who want talent to stay and strengthen the local economy. This is the geographic cut across the portfolio.
Fundraising Story 07 — The AI-Era Learning Institution
AI is reshaping the job pyramid into a diamond — hollowing out entry rungs and raising the bar for the rest. The durable answer isn't more front-loaded college; it's continuous, work-embedded learning. Reach is structurally the institution built for that world. This is the leading-edge, forward-looking story — and the one that ties Reach to Lossless's own AI work.
Pre-RAG Fundraising-Story Synthesis for Reach University — index, method, and how this changes once RAG/KAG lands
Seven recurrent themes pulled by hand from the reach-edu funder corpus (539 files across 57 funders), each framed as a fundraising story with its aligned funder cluster and cited proof points. This is the starter the operator asked for while proper retrieval (remote filesystem + SurrealDB vector/graph) is still a few days out — and an honest note on what synthesis looks like now vs. once RAG/KAG is real.
Pipeline Building & Automation — Scroll-Deck Outline
What Lossless will boot up for Reach next. Boost-and-relief for the current fundraise team, then widening the aperture to new donors, new grants, and a map of the philanthropic landscape.
reach-edu-hub/narratives
floaters/20
context-v for augment-it
Living documentation for augment-it — specs, habits, prompts, reminders, explorations, issues.
agent-harnesses
ai-labs
augment-it
context-vigilance-kit
conversational-ui-and-native-shells
corpora-builder
dididecks-ai
flave-ai
id-didi-sh
lossless-decks
memopop-ai
memopop-native
memopop-orchestrator
memory-layers-for-agents
open-specs-and-standards
reach-edu-hub
studies
sync-and-content-version-control
vector-databases
issue-resolution/3
Research Agent Concatenates Multiple Sources Under One Citation ID — And No Validator Catches It
`research_enhanced.py` writes several sources onto one `[^N]:` line, so downstream parsers keep the first and silently drop the rest.
Section Citations Orphaned When Definitions Live in 1-research/
`consolidate_citations.py` reads `### Citations` only inside section files, so defs living in `1-research/` become orphans.
memopop-orchestrator/issue-resolution
sitemap/32
/data-assets/slides — reviewer audit of the slide tier, one row per slot, adapted-vs-stub per variant
The third data-assets audit and the only one never promoted to the shell — adapted-vs-stub per variant, living only in calmstorm-decks.
DeckFrame--Play-UI — Play-UI chrome wrapper around SlideCanvas, plus the keyboard contract
Play-UI's outer frame at `/play/[deck]/[variant]/[slot]/` — `<SlideCanvas>` plus the floating DeckChrome and document keyboard listener.
DeckMatrix — the rich audit-rated dual-surface matrix; the deck-level review surface, embeddable on any landing
The embeddable variants × slots matrix: each cell pairs a Scroll-UI and Play-UI rating, with `≠` flagging where the two surfaces disagree.
DeckStatsPanel — the 4-tile quick-stats row above the matrix on landing pages (Variants · Slide Files · People · Companies)
Four-tile stats row above `DeckMatrix` — Variants, Slide Files, People, Companies — counted from the same globs `/data-assets/*` uses.
ModeToggle — three-mode color-toggle (light → dark → vibrant) with per-client localStorage namespace
Fixed top-right button cycling light → dark → vibrant, persisted under a per-client `{client}:mode` key so co-hosted decks don't collide.
PageAsDeckWrapper — Scroll-UI navigation primitive: scroll-snap + keyboard + section counter + reveal-on-intersect
Wraps `<section data-slot data-variant>` children in a scroll-snap deck: keyboard contract, section counter, and `#s-N` hash nav.
PlayChrome — DEPRECATED thin shim around DeckChrome
Deprecated as of v0.2 — a thin shim around `<DeckChrome>` kept so external imports keep working. Removed in v0.3.
ScrollDeckPage — THE single shell overlay for a scroll-deck variant page; one-import wiring
Collapses the three shell imports a variant page used to need — pagination, rating pill, mode toggle — into one component and mount site.
SlideShell — shared per-slide chrome (padding, min-height, snap-align, optional consumer-provided mark)
Outer `<section>` with shared per-slide layout plus a `<slot name="mark">` — consumers plug their own mark, the shell stays brand-agnostic.
lib/deck-overview — registry + filesystem walker; loadDeckOverview(deckSlug) returns DeckOverview with variants/slots/per-slide-file flags
`loadDeckOverview(deckSlug)` reads registry paths off `globalThis.__dididecksShellOptions`, so the shell never needs the consumer's imports.
Sitemap — Living Map of the DidiDecks Universal-Frontend-over-Client-Decks Architecture
One mini-spec per `@dididecks/shell` artifact — the universal layer; per-client overrides live in each client-site's own `context-v/`.
/data-assets/companies — reviewer audit of portfolio-company metadata + brand assets across every engagement layout
Reviewer audit over `data/**/portfolio/*.md` — companies are told from people by the *absence* of `role_class`. SSR'd behind auth.
/data-assets/people — reviewer audit of team / advisor / portco-ceo metadata + headshots across every engagement layout
Reviewer audit over `data/**/{team,portfolio}/*.md` — people are told from companies by the *presence* of `role_class`. SSR'd behind auth.
/play/[deckSlug]/[variantSlug]/print/ — one-shot PDF export surface; renders the whole variant stacked for the browser print dialog
Stacks every slot as SlideCanvas instances with `page-break-after: always`; no `@page` override, so the browser picks paper size.
/toc/[deckSlug]/ — deck-level dual-surface review matrix (one row per slot × one column per variant)
The deck-level review matrix: variants × slots with dual-surface ratings per cell, distinct from the per-variant `/toc/[deck]/[variant]/`.
runtime/mode-switcher — TS factory createModeSwitcher({client, defaultMode, respectSystemPreference}); per-client localStorage namespace
Three-mode state machine factory, namespaced to `{client}:mode` in localStorage and installed as a `window.modeSwitcher` singleton.
/dev/icons — recurring design-review workbench
A kept design-review workbench — one `/dev/*` page rendering every candidate for a visual-primitive decision side by side, in real context.
DeckChrome — themable floating navigation capsule for Play-UI (and eventually Scroll-UI variant cycling)
Floating bottom-right nav capsule replacing v0.1's dark PlayChrome bar; styling comes only from `--ddd-chrome-*` custom properties.
DeckOverlay--Play-UI — the floating overlay layer for Play-mode decks
Single mount point on the play-slot route composing DeckChrome and SlideRankPill; its `<section data-slot>` wrap is the play-mode adapter.
DeckOverlay--Scroll-UI — the floating overlay layer for Scroll-mode decks
Layout-neutral (`display: contents`) mount for the affordances riding over a scroll deck — each a named slot consumers can rearrange.
DecomposeFirstPlaceholder — empty-slot fallback rendered when a per-slide file doesn't exist yet
Empty-slot fallback on the play route — an invitation to begin the rank → decompose → recreate loop, deliberately not an error state.
DididecksNav — shell-injected global header linking Scroll · TOC · Play · Changelog
Shell-injected global header auto-mounted on `/toc/*` and `/play/*`, with links derived from the consumer's own deck registry.
SlideCanvas — pure-CSS 16:9 wrapper that scales a 1920×1080 stage to fit any canvas
Pure-CSS 16:9 stage — container queries scale a 1920×1080 design size to any canvas, so the Play-UI scaling pipeline needs no JS.
SlideRankPill — floating five-button classifier for the active slot (rename pending → SlideClassifierPill)
Bottom-right floating pill exposing the five-state classifier for the active slot, found via IntersectionObserver over `section[data-slot]`.
/api/slide-decompose — non-destructive stub generator for the Phase 1 → Phase 2 transition
Dev-only route that writes an empty per-slide stub and refuses to overwrite — 409 if the file exists. Static Vercel builds never carry it.
/api/slide-rank — read + write per-slide classifier state into the consumer's audits file
Dev-only GET/POST over `data/audits/slides.json` — `'pending'` is never persisted; posting it deletes the entry. 404s in production builds.
/play/[deckSlug]/[variantSlug]/ — variant-index redirect to slot 01
Enumerates every (deck, variant) and 302s to slot 01 — unconditionally today, so slot-less variants like chroma's proto land on a 404.
/play/[deckSlug]/[variantSlug]/[slot]/ — single-slot Play-UI renderer with keyboard nav
Static per-slot route: dynamic-imports `slides/{variant}/{slot}-{slug}.astro` into SlideCanvas, falling back to DecomposeFirstPlaceholder.
/toc/[deckSlug]/[variantSlug]/ — bird's-eye-view audit dashboard with rank pills + scaffold buttons
Per-variant TOC — one row per slot with five rank pills and a scaffold button POSTing to `/api/slide-decompose`. Read-write in dev only.
Reach Education Hub — `/` Index Page Brainstorm
Working doc on what the hub homepage communicates, who it serves, and the order of the scroll. Brainstorm, not a spec.
dididecks-ai/sitemap
reach-edu-hub/sitemap
refactors/6
The federal layer never shipped --space-*, --radius-* or --z-* — so ten members invented token names and let the fallback carry the value
170 declarations across the federation reference tokens that do not exist. Each one silently ships its literal in all three modes.
sort-filter-lens leaks 61 unnamespaced classes into every other remote — and .error, .row and .muted are live collisions today
One member ships 511 lines of global CSS with no root-class containment. Sixteen other surfaces render a class it restyles.
Two palette steps share one hex, so dark-mode borders measure 1.00:1
graphite-700 and graphite-800 are both #232634. Four federal boundary findings came out of one member's probe; three survive adjudication and one does not.
Rename the corpora curator — finishing a rename that only ever reached the label
Four naming layers were tangled here and only three moved — the fourth is a data value living in two external client repos.
Structural refactors surfaced by the codebase graph — the deadweight, the boilerplate, and the CSS convergence problem
A zero-token graph over 490 files found ~500 lines that delete cleanly, 11 near-identical `mount.ts` files, and no duplicate CSS after all.
augment-it/refactors
notes/6
Sharing code without breaking microfrontend autonomy: build-time import IS the copy
With no `shared` block, a workspace import is inlined into all seventeen bundles. The cost isn't runtime coupling, it's redeploy fan-out.
Why this monorepo does not need Turbo: a task graph with no edges
Turbo's core directive is `dependsOn: ["^build"]` — build my dependencies first. No package in packages/ has a build step, so it resolves to nothing. We adopted a best practice for an architecture we then didn't build.
The four layers: pnpm, Turbo, rsbuild Module Federation, and where Bun would fit
There isn't one 'monorepo' system — there are four independent ones, and the word 'federation' means two different things across them. Untangling which tool owns which job, and what Bun would actually replace.
Two tiers: WebSocket to the gateway, NATS between services
The browser talks WebSocket to one gateway; the gateway talks NATS to every service. They aren't alternatives — they're two legs of one design, and the gateway between them is where tenancy lives.
augment-it/notes
id-didi-sh/notes
inquiry/5
Agent Harnesses — Answers to the Plan's Targeted Questions
Phase 2, not a survey: three questions — MCP tool scoping, trajectory logs, per-project config swaps — answered from the profiles.
Conversational UI / Native Shells — Answers to the Plan's Targeted Questions
Phase 2, not a survey: two questions — Dive's Electron/Tauri migration and anything-llm's workspace switch — answered from the profiles.
agent-harnesses/inquiry
conversational-ui-and-native-shells/inquiry
open-specs-and-standards/inquiry
slides-content/5
briefs/2
ideas/2
Ideas — the editor surface and the format
Fifteen ideas captured from a working session, sorted by what they would actually cost. Four are nearly free because the groundwork already shipped; two need work upstream in lfm before flave can touch them; one is already an open decision in the spec under a different name.
flave-ai/ideas