Meta Global AI Developer Hackathon — compliance
For Autumn's meta-styles entry (Indie Developer track, theme "Build for
Your World" — see ~/projects/meta-styles/docs/decisions.md). Event runs
Oct 26 – Nov 4, 2026 (Cerebral Valley x Meta).
When to Use
Work on meta-styles: app code in ~/projects/meta-styles (direct or
delegated), its commits and deploys, the prior-work IG bot integration that
feeds it, and live debugging of the bot/wardrobe/proxy stack. Not other
projects.
Source and verification
The Organizers' own Official Rules / Event Waiver text (not a summary)
was fetched 28 Oct 2026 from
https://cerebralvalley.ai/e/meta-ai-developer-hackathon/waiver via
web_extract — this bypasses the client-side login wall that blocks a
plain browser view of that page. Full saved text:
~/.hermes/profiles/verdant-companion/cache/web/cerebralvalley.ai-ff6be7c2a9.md.
The Organizers can modify these terms at any time ("Modifications" clause)
— re-fetch the waiver URL before final submission to catch changes.
Confirmed facts (from the event Discord FAQ "Submissions, prizes and resources", pasted by Autumn 28 Oct 2026)
- Demo video length confirmed: 3 minutes — retires the last item that was still unverified below.
- Submission package: one project per team/startup, submitted by the team Representative via https://cerebralvalley.ai/e/meta-ai-developer-hackathon/hackathon/submit, containing a 3-minute demo video, a public repo link, and every contributor's name. Judges assess video, code, and the live product — so the app needs to actually run live, not just look good on video. Check both links resolve before submitting.
- Deadline is hard: Nov 4, 9 PM ET, late submissions not considered — no grace period, confirmed explicitly (not just assumed).
- Bonus prizes, now itemised (on top of the five per-track placements): Most Viral Project $20k, Best Build on Meta Open Weight Models $10k, Community Vote $10k, Best Agentic Use-Case $5k, Best Creative Build $5k. meta-styles angles: "Best Agentic Use-Case" fits the fit-rule assembler + Spark copy generator pipeline if it's framed as agentic reasoning, not just a form-filler; "Best Creative Build" fits the Y2K-x-fairycore styling angle.
- Most Viral Project: post the demo on X, submit the post link through the platform; engagement counts through Nov 8 EOD.
- Community Vote: opens Nov 9, one vote per verified account, winner announced Nov 16 (already noted above).
- Learning resources: Quickstart (dev.meta.ai/docs/quickstart), model list (dev.meta.ai/docs/models), API cookbook (github.com/meta-models/meta-model-cookbook), open-weight cookbook (github.com/meta-models/meta-oss-cookbook) — check the API cookbook before wiring the real Meta Model API calls into spark.js/preview.js.
- Live workshops, noon–1 PM ET: Oct 27 Agents 101, Oct 28 Agents 102, Oct 30 Fireworks inference/training — the Fireworks one is relevant given Autumn's unrelated Fireworks/Muse Glimmer training-credits thread.
Confirmed facts (from the event Discord FAQ "Project rules", pasted by Autumn 28 Oct 2026)
- New work only, now fully confirmed: you may build on an existing
project/startup, but the submission and demo "must clearly identify —
and only showcase — the features, code and functionality built during
the hackathon. Unclear original contributions can lead to
disqualification." This retires the earlier "unverified" flag —
docs/prior-work-instagram.md's approach (explicit pre-hackathon disclosure, nothing from SecondBloom shown as a meta-styles feature) is exactly the compliant pattern. - Public repo, now fully confirmed: "Your repository must be publicly
accessible." Before making the repo public: re-run the key/token grep
across the whole tree (last done 28 Oct 2026, clean) and confirm
.env/secretsis still gitignored and not ingit ls-files. - Judging gate, now fully confirmed: projects must first fit a theme AND "meaningfully use Meta Model API and/or Meta open-weight models" — this is a pass/fail gate before the four equally-weighted scoring criteria (Impact, Use of Meta AI tooling, Technical depth and execution, Demo quality) apply. Retires the last "unverified" item from that list.
- Avoid-list (explicit disqualification risk): the guide names AI medical advice / mental-health advisors / skin-condition detectors, basic RAG apps, simple image analyzers, generic education chatbots, job-application screeners, nutrition coaches, personality analyzers, sports analyzers/coaches, and anything political or war-related. Risk for meta-styles: a garment classifier + segmentation viewer could read as a "simple image analyzer" if the demo leads with the raw classify-a-photo mechanic. Mitigate by keeping the pitch and demo framed around the full-look assembly + fit-rule reasoning + resale-grounded copy (the part no "simple image analyzer" does), not the SAM/classifier step in isolation. Flag any doubt to @CV on the event Discord per the FAQ's own suggestion rather than guessing.
- Only top 5 projects per track advance to finals (indie track has up to 20,000 participants per the application cap, so this is a steep cut).
- Disqualification also covers using code/data/assets without permission —
reinforces why
docs/prior-work-instagram.mddraws a hard line around SecondBloom rather than quietly reusing its code.
Confirmed facts (from the event Discord FAQ, pasted by Autumn 28 Oct 2026)
- Project must use Meta models and address one of the two themes (Build for Your World / Push the Frontier) — this upgrades the "hard pass/fail gate requiring genuine Meta model use" item from unverified to confirmed: the FAQ states it as a requirement, not just a scoring factor.
- Full model list confirmed: Muse Spark, Muse Wonder, Muse Image, Muse Voice Transcribe, SAM 3.1 (via Meta Model API), plus open-weight Muse Glimmer and Muse Spark Open. Muse Code is explicitly named as available "to help you code" — organizer-sanctioned, not just inferable from the Official Rules' third-party-assistance clause.
- Building period is Oct 27 – Nov 4 (kickoff itself is Oct 26 at noon, separate from the building period start) — sharpens the earlier "kickoff Oct 26" note; if "new work only" is enforced, Oct 27 noon ET may be the safer cutoff for "work done before the hackathon" rather than Oct 26.
- Community vote winner announced Nov 16 (later than the Nov 9 main closing ceremony / winners announcement).
- Solo entry explicitly confirmed fine; teams up to 4; team-forming and intro channels exist on the event Discord.
Confirmed facts (from the Official Rules text itself)
- Track: Indie Developer — teams of up to 4, one Representative submits and must identify all other team members. (meta-styles is solo.)
- Dates: kickoff Oct 26 (livestream), workshops Oct 27–Nov 4, submission due Nov 4, 9:00 PM ET, judging Nov 4–8, winners Nov 9.
- Hackathon submission judging (distinct from the application-stage criteria, which are idea clarity + technical skill only): Impact 30% (real-world potential, who benefits, fits a problem statement), Use of Meta AI Tooling 25% (creativity beyond a basic integration, unexpected capabilities), Technical Depth & Execution 20% (sound, refined engineering, real craft), Demo 25% (working/impressive live demo + demo video quality).
- Third-party technical assistance is explicitly allowed: "Participants
may contract with a third party for technical assistance, provided the
Submission components remain the Participant's own work and the
Participant owns all rights to them." This directly covers delegating
implementation to Muse Code and to Bramble (Claude) — Autumn directs and
owns the result, so it's compliant. Keep doing this openly (commit
authors
claude-code/muse-codeare fine, not something to hide). - Open source is allowed if applicable licenses are followed and the submission "enhances or builds upon" the open-source component (not just a repackage).
- IP: Autumn retains ownership of the submission; by submitting she grants Organizers a broad perpetual license to use/display/adapt it (marketing, demos, etc.) — expect no confidentiality for anything shared during the event (Discord, workshops, screen shares, the submission itself are all explicitly non-confidential and may be recorded).
- Credits: $150 in Meta Model API credits for a 10-day window if selected — read the linked Credit Terms PDF before spending any of it.
- Eligibility: 18+, not in a sanctioned country/org, not a Meta/Cerebral Valley employee/contractor/intern or their immediate family.
- Judges' decisions are final and binding; winners go through eligibility verification before payout (30 days after verification, W-9/W-8BEN required).
Unverified / community-sourced — do not treat as binding
All previously tracked unverified items (new-work-only, public repo, the Meta model usage gate, and the 3-minute demo video length) are now confirmed above by the event Discord FAQs. Nothing outstanding here as of 28 Oct 2026 — re-check this section before final submission in case new FAQ content lands.
Standing rules for every task on this project
All hackathon code (anything in
app/,mock-ig-bot/, etc. — new work claimed as built during the hackathon, including any genuinely executable new file regardless of its path, e.g. a root-level install script) is implemented by delegating to Muse Code or OpenCode/Muse Spark, not written directly by Bramble/Claude. This governs IMPLEMENTATION only — a read-only critical-review pass (no edits, no commits, one output markdown file) is fine to delegate to a Claude Code/Opus subagent on the same hackathon-code paths, same as it's fine for Bramble to review them directly; keep that subagent's instructions explicitly read-only so it can't slide from reviewing into implementing. (Autumn, 28 and 29 Oct 2026 — confirmed OpenCode satisfies the same rule). Commit identity by delegate: Muse Code work asmuse-code <muse-code@noreply.invalid>; OpenCode/Muse Spark work asopencode-spark <opencode@noreply.invalid>; Bramble's own docs-only analysis asclaude-code <noreply@anthropic.com>. Bramble's role on this repo is: write/review specs and docs, construct the delegation prompt, verify the delegate's output (tests, diffs, leak-grepping, attribution), fix commit attribution, and push — not hand-edit the app code itself, even for a one-line change. If a quick fix seems easier to just make directly, delegate it instead (edit mode is fine for something that small) and review as usual. Docs-only edits that are Bramble's own analysis/decisions-recording (not new hackathon functionality) are unaffected by this rule.Prior work stays prior work. SecondBloom/
igwebhook(and anything else predating the build window) is documented indocs/prior-work-*.md. Autumn may extend it — that counts as maintenance of the old project: build it outside the meta-styles repo, never vendor its code in, never demo it as hackathon-built, and update the prior-work doc in the same change. The Muse-Code-only rule above applies to hackathon-code paths inside the meta-styles repo — it does not extend to the separate prior-work repo. Maintenance there (a new route, a bugfix) may be delegated directly via Claude Code/Opus (see theclaude-codeskill) rather than Muse, since it is a different, non-hackathon codebase with its own git history and no-remote/low-risk posture to confirm first; still delegate non-trivial changes rather than hand-editing, scope any infra-touching change per theclaude-codeskill's safety split (new public routes/firewall changes get drafted not executed), and keep ALL real-send/live-credential actions gated by the send-approval rule below regardless of which tool built the code. Only the meta-styles-side client/integration code is new work. When the prior-work service gains a capability the hackathon demo should mirror (e.g. a new storage contract), the hackathon-side build is a fresh, independent implementation of the same CONTRACT (same routes/shapes) delegated to Muse like any other hackathon code — never a port of the prior-work service's actual source. Cross-reference the prior-work design doc for the contract shape; don't copy its code.Demo/test data is synthetic. Never copy real captured data (DM photos, shares.jsonl rows, real account/media IDs) into the repo — create fixtures from scratch that match the real schema (
SYNTH_ids,example.invalidURLs) and say so in comments. Check after any delegation: grep the diff for the real app/account/media IDs.Prior-work services that feed the app stay off the internet — local-only on this machine (see
meta-instagram-integration). Consequence for judging: any feature fed by such a service works only on this machine, so the client must fall back cleanly to synthetic fixtures when the local endpoint is unreachable, and the demo video should be recorded here. Say this tradeoff out loud whenever a plan adds such a dependency. A local live-testing switch may point the client at the real prior-work bot, but it must be explicit (for exampleLIVE_IG=1), preserve the mock default, generate ignored runtime configuration without printing credentials, and never send externally during startup or polling.Commit attribution must be honest and resolve correctly. The repo's
git config user.name/emaildefaults toclaude-code, so committing is never a no-op on authorship — decide first: changes toapp/,meta-api-proxy/,mock-ig-bot/, or any other hackathon-code path get authored asmuse-code(oropencode-sparkwhen OpenCode did the work) (even when Bramble is just staging/committing code Muse already wrote in an earlier pass, not authoring it fresh); changes confined todocs/,skills/, or Bramble's own analysis getclaude-code. Override per-commit rather than touching repo config:git -c user.name="muse-code" -c user.email="muse-code@noreply.invalid" commit -m "..."(swap forclaude-code <noreply@anthropic.com>on docs-only commits). The author email must not belong to a different GitHub account (GitHub links commits by email) — seemuse-codepitfalls. Before everygit pushon this repo, check authors first, not just at commit time: rungit log origin/master..master --format='%h %an <%ae>'over the whole unpushed range (not just HEAD) and confirm each commit matches app-code-vs-docs rule above and uses a safe placeholder email (noreply@anthropic.com,*@noreply.invalid), never an email that resolves to a real GitHub account. This catches a stale identity or a mis-attributed commit that slipped in from an earlier session before it goes public. A non-fast-forward rejection right after your own pushes landed usually means a stale local remote-tracking ref, not real upstream work:git fetchthen checkmaster..origin/master— your own commits on that list = fetch staleness; fetch +git pull --rebase+ push, and theskipped previously applied commitnotes the rebase prints are harmless duplicates. If commits you made seem missing fromgit logentirely, check commit DATES andgit log --all --grep='<subject words>'before diagnosing dropped work — this repo is developed continuously by parallel delegate sessions and cron lanes, so a history that looks 'past your session' can simply mean the repo moved on, and re-committing the working tree blind would double-land someone else's landed feature.Hold real API keys until Autumn says go; record each go/hold in
docs/decisions.md..env/secretskeys are hyphenated (meta-api-key,ig-bot-token) — parse the file, don'tsourceit.Every agent working in the repo is bound by
AGENTS.md, which points here; when a rule changes, update this skill, then re-copy it toskills/meta-hackathon-compliance/SKILL.mdin the repo. Don't trust that the last session actually did this — the repo copy drifted significantly out of sync (missing a whole section) because the re-copy step was easy to skip under task pressure. At the start of any session touching this repo, diff the repo's checked-in copy against this master skill's current content and resync if they differ, before relying on either as authoritative for an agent that reads the repo copy instead of this one.Open decisions go to Autumn, recorded as resolved/struck in the doc (decisions.md, the spec's open-questions list) rather than deleted, so the rejected option stays visible.
Before assigning a roadmap milestone to Muse (or building it yourself), check whether it's already satisfied by existing wiring. Grep for the shared integration point the new milestone would add to (e.g. a milestone that says "feed X through the existing pipeline" may already work if X already calls the same entry point other inputs use) before spending a delegation on it. Report "already done, here's why" instead of assigning busywork — the milestone list can lag what the code already does, especially right after a prior milestone's implementation changed the data flow.
A decisions.md/roadmap.md row marked OPEN or unresolved may already be fixed in code — the cron pipeline lands commits without always flipping the row's status. Before treating any such row as a live blocker (or reporting it to Autumn as outstanding), grep the actual repo for the thing the row says is missing (the linked file, the handler, the workflow, the live URL) and check recent commit log /
gh run listfor a matching fix, not just the doc text. If the fix is already live, close the row with a RESOLVED note citing the commit/URL that proves it, rather than re-opening a dead task or re-delegating already-done work.Before "launching"/"exposing"/"setting up" anything operational for this project (the local app stack, a public guide, a tailnet link), check live state first rather than assuming a fresh setup is needed — this project accumulates long-running infra across sessions.
ss -ltnpfor the three local ports already listening (proxy/mock-bot/static),ps -o pid,etimes,cmdon those PIDs to see how long they've been up,gh api repos/codepilots/meta-styles/pagesfor an existing Pages deployment, andtailscale serve status --jsonfor an existing tailnet proxy route are each a 5-second check that can turn "build this" into "here's the link, already live" — verify with a realcurlagainst the candidate URL/port before reporting it as working either way. A port being up and healthy does NOT tell you which MODE it's serving — a prior LIVE_IG=1 session leaves:8000bound bylive-proxy-server.js(relaying to the real bot at:8903with real bearer tokens pushed into the browser) and that is indistinguishable from mock mode by a bare health/port check. Before calling a running instance "the mock"/"the demo", check thecmdfield frompson the:8000process (python3 -m http.server= mock;node live-proxy-server.js --bot ...= live) and whetherapp/ig-runtime-config.jsexists (present = live, generated bystart.sh LIVE_IG=1; absent = mock). If a session asked for "the mock"/"simulates Instagram" and the running instance is actually live, kill the proxy/live-proxy/wardrobe-service PIDs, delete the staleapp/ig-runtime-config.js, and relaunch with plainMODEL_API_KEY=<key> sh start.sh(noLIVE_IG) — don't just reuse what's already listening. The mock bot's CORS allowlist trusts the exact originhttp://localhost:8000and rejectshttp://127.0.0.1:8000(same host, different origin string) — every link, browser test, orcurl -H Origin:check against the mock/judged path must uselocalhost, never the bare IP, or requests silently fail client-side with no server-visible error.To give the MOCK demo a working remote/Tailscale link (not just the local-only judged path), repurpose
live-proxy-server.jsto target the mock bot instead of the real one — don't accept "remote access doesn't work" as final, and don't improvise a different tunnel.start.shonly wires the same-origin proxy underLIVE_IG=1(pointed at the real bot); for mock mode, launch it by hand instead of the plainpython3 -m http.server:node live-proxy-server.js --port 8000 --bot http://127.0.0.1:8904 --proxy http://127.0.0.1:8905 --wardrobe http://127.0.0.1:8906 --dir app, plus a hand-written, gitignoredapp/ig-runtime-config.jssetting{ mode: "mock-remote", botBase: "/ig", proxyBase: "/api", statusBase: "/wardrobe" }(no tokens needed — the client's own hardcoded mock token already matches what the mock bot expects). This needs three fixes — seereferences/wiring-pitfalls.md§Remote access via same-origin proxy for the full detail, confirmed necessary again on a from-scratch rediscovery: the proxy must rewrite the outboundOriginheader rather than relay the browser's real one, the mock-only/mock/*operator routes need their/igprefix stripped specifically on that branch, and any client page must gate its "am I live" checks on an explicitmodefield rather than inferring liveness frombotBasebeing set. A skill bullet claiming a fix is "already landed in the repo" is a claim, not a guarantee —search_files/git diffthe actual current file for it before trusting that or re-deriving it from scratch; this exact bug was fully fixed once, documented here, and still had to be rediscovered and re-fixed from zero in a later session because nobody checked this reference first.A capability that writes/sends to a real external user (not just reads) is a stricter case of the prior-work gate, not the same one. Read-only bot extensions (like the Milestone 9 API) only needed Autumn's go-ahead to build; anything that can act on a real person on the other end (send a DM, post, notify) needs her explicit go-ahead before a contract spec is even drafted, must surface the platform-specific risk (messaging windows, rate limits, consent) as explicit open questions rather than assumptions, and must preserve any privacy decision already made on the read side (e.g. if a recipient identifier is never exposed to the client, design the write/send request to reference the existing opaque id instead of a raw identifier, not re-expose it "just for this one feature").
When a Muse-written plan doc comes back with a numbered open-questions list, walk Autumn through them one at a time (one question, her answer, next question) rather than dumping the list — matches how she drives multi-item decisions generally. Record every resolved answer into
docs/decisions.mdyourself as a new numbered row (Bramble's job, not Muse's, per the rule above); only after all questions are resolved, build ONE consolidated revision prompt for Muse that restates each answer against the open-question number it resolves, and re-delegate as a singleedit-mode call — don't dribble out one micro-delegation per answered question.If resolving one open question implies un-parking or reversing an earlier parked/descoped/avoid-list-flagged decision (e.g. an answer that needs a previously-descoped milestone), say so explicitly to Autumn before folding it into the next delegation prompt — don't silently adopt the implication. The original parking reason (often an avoid-list risk) doesn't evaporate just because a later answer needs that capability; restate the risk and how the new framing still mitigates it, in the same breath as recording the decision.
Multi-row edits to the numbered decision tables in
docs/decisions.md(ordocs/roadmap.md): append the new row(s) after the last existing row, never insert before/between existing rows — inserting mid-table risks renumbering drift and, if the replacement string is built programmatically, a literal\ntwo-character sequence landing in the table instead of a real line break. When using a find-and-replace patch tool for this, makeold_stringmatch ONLY the exact boundary text you want to anchor on (e.g. the start of the next unrelated section), and make surenew_stringstill contains every original line your match spans — anchoringold_stringon the last existing row's own text and then writing anew_stringthat doesn't repeat that row's content silently deletes it, which is exactly how a row disappeared even though the edit was logically an append. After any such edit, immediatelyread_filethe result (don't trust the diff summary alone) and confirm every original row is still present, in order, with no literal backslash-n in the rendered text, before moving on.Fence every delegation prompt against deletions, and check
git statusafter each run — OpenCode/Muse Spark oncerm -rf'd an unrelated untracked directory (.cron-prompts/) that no instruction mentioned. Add "do not delete or modify anything outside the named files; do not run rm" to every delegation prompt regardless of how clearly bounded it seems. Untracked-file deletion is unrecoverable (never in git history, no filesystem copy) — verify the tree diff before celebrating a green test run.After every delegation run,
git status --shortfor UNTRACKED files andgit addthem by exact path before committing — then re-run the full suite yourself. A timed-out or partially-finished Muse/OpenCode run leaves its new test files on disk untracked; agit addlist containing one unmatched glob pathspec stages NOTHING (git aborts the whole add, then the commit reports "up to date" as if done) — a commit has shipped without the delegate's tests this way. The delegate's final "all green" is a self-report: mid-run failures it quietly fixed afterwards still happened in the transcript, and the final count must come from an independent run before the push. When a run outlives the call's timeout, the client dies but its edits persist — after a timeout checkpsfor a still-running client andgit diff --statfor what landed, then re-delegate ONLY the missing remainder as a new run stating "implementation already applied (commit , files ); skip implementation, add tests only" — re-running the full prompt on a half-applied tree produces double-drifted edits and churned tests.Product scope decided 2026-10-29 (Autumn) — governs every M19-and-later task: the product is the persistent per-user wardrobe/catalog, not the chat — Instagram DM chat is one interface onto it, not the product boundary, so no catalog schema work may couple itself to IG-specific fields. Fabric/price/vendor grounding is fully descoped (a boutique-sourcing-DB integration is a separate future stretch, blocked on hosting + a PII photo-scrub pass, not to be folded into the current build). Judge delivery is a local one-shot install+run (judge supplies only their own Meta API key) — not a hosted URL; hosted live Instagram integration and real-DM sends are stretch goals only, both still gated by this skill's send-approval rule if pursued. If a build step runs long, the step itself gets time-boxed/descoped — the submission's existing critical-path milestones (isolation proof, packaging, submission cut) do not give way for a scope addition. Full detail:
docs/milestone-19-chat-first-pivot.md.Live wiring pitfalls (Oct 30, verified live): sibling() lookups, origin checks, and dedup scope all have distinct failure modes that Node tests mask — see
references/wiring-pitfalls.md.An automatic (server-initiated) reply that includes a generated image is a distinct display path from an operator manually attaching a file in the browser — don't assume the former works just because the latter renders. If a page's "show the staged image" logic only ever populates from a browser-local upload (never fetched from the server), every auto-sent look/image reply silently degrades to placeholder text with no image, even though the image really was generated and "sent" server-side. Same class as the other "claims delivery that didn't happen" bugs in this skill — see
references/wiring-pitfalls.md§remote access via same-origin proxy for the exact fix shape (a debug-only read route plus an async-fetch-then-patch client pattern mirroring how incoming photos are already fetched).Agentic interaction design (Oct 30, Muse Spark): proscriptive router + skill set, persona, and memory rules distilled from Autumn's edits — see
references/interaction-design.md.User-data deletion is only real when every holder of the data observes it; deletion logic stays hard-coded in the prior-work IG bot. Downstream stores reconcile against the bot's deletion-truth endpoint and drop state only on a definite truth — 404/5xx/bad-JSON fails open, so a transient outage can never wipe a wardrobe; deleting a file alone is not deletion, and any new user-scoped store must join the story. Phrases stay in lockstep with the consent copy plus bare DELETE/FORGET ME, and the YES check precedes any punctuation stripping. Detail:
references/wiring-pitfalls.md§deletion reconciliation.Grounding: look references render at ~384px from stored per-piece originals (≤1 MB), falling back to the 96px thumb for pre-original pieces. Verify three separate seams: the right catalogue record is selected, the derived reference is actually present in the provider request, and the generated result preserves the supplied garment. A green delivery counter or captured input payload never proves garment-following; inspect source/result dimensions and visible content, and validate the provider's documented image-edit request shape before blaming the model.
references/wiring-pitfalls.md§grounding.Keep personal render references separate from wardrobe pieces. Headshots and full-body photos belong in a user-scoped profile-reference store, never in the piece-array schema or garment catalogue. For a render-on-user request, require explicit consent before persistence, ask only for missing reference types, route pending uploads to profile storage rather than
catalogue_piece, and pass both references to the image model only when the user explicitly requested a worn render. A normal look request must remain flat-lay and must not demand profile photos. Implement a real delete path for profile references and verify both the storage layer and downstream model payload observe deletion; never claim identity-preserving rendering or encrypted storage unless the bytes actually reached the model/storage contract.Test the privacy boundary as a reachable flow, not just a helper. Cover fresh render intent with no references (no preview call/no image), one-reference-missing prompts, sequential labelled or bare uploads, explicit-consent persistence, delete-and-reask, and the ordinary flat-lay path. Include a browser-shaped or VM test whenever production code has both
root.MetaStylesandrequireresolution, because Node-only tests can leave the real upload/router path unexercised. Test the separate profile API as well as the handler: use a valid production-shaped user reference, prove encrypted-at-rest persistence plus idempotent deletion, and assert status/debug responses contain presence metadata only—not profile bytes. A passing handler test with an invalid user-ref fixture can miss the real route entirely.Model answers coerce into the closed vocabulary at the integration seam — a fail-closed validator downstream plus an unconstrained prompt upstream is a silent fail-soft failure chain. Exact match passes; synonyms coerce; deliberately-untracked answers return the honest
placeholder:truefallback (which callers treat as classify-unavailable, never as a confident label); caches store post-coercion values.references/wiring-pitfalls.md§coercion seam.Cataloguing is one photo → every garment: detections accumulate into one pending bag per user, one combined ask per batch, add on yes with per-region attribution and crop-fingerprint dedupe; single-region findings keep instant auto-add; a stray or repeated yes gets its own honest nothing-pending reply. §multi-detect in
references/wiring-pitfalls.md.The pending-add branch gates on the DURABLE bag, never on a consumable marker another layer resolves first (a pre-skill expectation mechanism consumes the recorded yes/no question before the handler runs — a handler gated on the question list treats an answered yes as nothing-pending and never touches the bag); and the collected source is acked only when the processing landed — a failure reply is a successful send, not progress. Gates read structured result fields, never trace strings; retained media stays discoverable via the pending state. §multi-detect, §media retention.
A catch chain that swallows must surface a classified failure kind into the result; telemetry records the verified outcome, never the skill's name; the status surface carries a minimized per-turn trail. Trace strings are diagnostics for humans, never gate conditions. §failure telemetry.
Per-share identity is per ATTACHMENT (
<mid>:<media_id>, bare mid for texts; a duplicate delivery intentionally collides into the same id) — and every consumer must accept it: send, staging, record lookups, AND id-derived strings with their own caps and encodings. §id contracts inreferences/wiring-pitfalls.md.Trace every hop from live telemetry before reading code, in the real input format not the fixture format; when the tool trail can't separate branches, instrument + probe per
references/live-debugging.md— the loop's tool recorder logs calls BEFORE applying, so an absent tool call is definitive proof it never ran, while a present one proves nothing about success. For an "isn't replying" report, split outbound-sent / inbound-arrived / perception-gap and canary the deployed public webhook path (read the REAL path from the deploy README; a guessed path's 404 proves nothing).A contract fix is not live until both running processes execute it — the redeploy is part of the fix. Bind-mount ≠ module reload; restart, then verify currency (StartedAt postdates the edit; the new symbol greps in the running process); never queue a foreground
sleep N; curlreadiness chain (the approval gate holds it silently) — verify from the background session's output or a bare status curl; and never trust apkill -fexit code (the pattern can kill the invoking shell) over a fresh process listing.**A share catalogues at most once, even across failed-send retries — the guard checks its source id before adding; never dedup/wipe at load time (the owner's deletion-path reset is the auditable story); the idempotent reply is per-PIECE distinctive, deterministic from a stable stored field (never a mid/user_ref in the text), so identical guard texts across different pieces can't trip the same-text backstop while the same piece still replays byte-identically.
User-facing pages (guides, landing/about surfaces) use this project's hand-drawn system: the guide palette (paper
#f7f5f2, ink#14171a, rule#ded9d2, accent#0d5c52), illustrations as single-fine-weight line-drawn SVG (round caps/joins, hand feel, dashed only for selection/motion, one heavier accent tier for hero emphasis — normalize stray stroke widths to that two-tier grammar before shipping), real reply copy quoted from the shipped skills, title phrasing matching the parent page, self-contained/no-JS, and a contents nav with anchors. Reuse the parent guide's header/nav structure rather than inventing a new one.**
Running-process staleness after a delegation lands
- A Muse delegation editing
app/,wardrobe-service/server.js,mock-ig-bot/server.js, ormeta-api-proxy/server.jsdoes NOT take effect in the already-running demo stack — Node requires() files once at process startup and never reloads them. Static.html/.jsfiles served by the python/live-proxy static server ARE read fresh per request (no restart needed for those), but any change to aserver.jsthat's already running as a background process needs that process killed and relaunched before you test it live — this bit the same session three times in a row across the view/delete/occasion-aware-look features. After every full-mode Muse run that touches a server file, checkps auxfor that file's running pid, confirm its start time predates the new commit, and restart it (same launch command used before) BEFORE doing any live browser verification — don't just assume a cleangit log/green test suite means the live demo reflects it. - Verify browser/UI changes against the SERVED URL, not the source
file, and verify structurally when the data surface is empty.
curlthe running page URL and grep for the new CSS/logic string — a stale proxy or restarted-wrong static server passes source greps while serving old markup. When history was cleared/tombstoned (e.g. after a delete-all) the thread renders nothing, so behavior can't be demoed: assert the cap/anchor structurally instead — inject an oversized element into the live page's DOM and measure its computed size viajs('(() => {...})()'), verify the scroll-into-view code exists in the served page, and let the first real interaction prove the behavior. - Restarting
wardrobe-service/server.jsresets its in-memory cursor and re-walks the mock bot's share history from scratch on the next poll — harmless for a demo, but expect a burst of "catalogued a piece"/ idempotent "already went out" activity lines before it catches up to genuinely new messages; don't mistake this for a bug.
Practical checklist for meta-styles
- Keep pre-hackathon work clearly separated and dated — now a hard
rule, confirmed by the Discord FAQ ("must clearly identify — and only
showcase — features/code/functionality built during the hackathon").
Already done:
docs/prior-work-instagram.mdstates the SecondBloom Instagram integration predates the hackathon by 12 days and is not part of this repo's code; git commit timestamps corroborate it. Use the building-period start (Oct 27 noon ET) as the strict cutoff if it ever matters, not the kickoff livestream (Oct 26 noon ET) — meta-styles' own first commit (4afac15) predates both anyway. - Watch the "simple image analyzer" overlap risk. The avoid-list explicitly bans basic RAG apps and simple image analyzers. Keep the pitch/demo centred on full-look assembly + fit rules + resale-grounded copy, not the SAM/classifier step in isolation. Ask on the event Discord (@CV) if genuinely unsure before investing more build time.
- Document AI-agent assistance transparently — it's explicitly allowed by the Official Rules. Don't scrub Muse/Claude commit attribution.
- "Use of Meta AI Tooling" is 25% of the score, and using Meta models is
now a pass/fail gate too — the app is currently stubbed
(classifier/spark/preview all placeholder). Before final submission,
swap in real Meta Model API calls (Spark/Image/SAM) sourced from
.env/secretsperdocs/decisions.md§Secrets — but only once Autumn says to start using the real key (she asked to hold off as of 28 Oct 2026). This is no longer optional polish — without it the submission fails the gate. - Repo must go public before final submission — confirmed requirement,
not yet done. Before flipping visibility: re-run the key/token grep
across the whole tree (last clean run 28 Oct 2026), confirm
.env/secretsisn't ingit ls-files, and confirm no proprietary SecondBloom code is vendored in — only docs referencing it. If the submission includes a static public guide, deploy it as a separate GitHub Pages artifact and verify both th
…(truncated)