Repset

Move while the model thinks: private movement breaks at natural Codex task boundaries.

Comment

Inspiration

Repset started with a personal problem I kept noticing during long Codex sessions.

I had used Codex to help me build websites, web apps, and mobile apps, but this was my first time building a Codex plugin. When I gave Codex a large task or a detailed implementation plan, I often stayed in front of the screen waiting for the result. I was excited to see what it produced, so I kept watching even when there was nothing I needed to do. I moved less, stared longer, and sometimes finished the session feeling physically uncomfortable.

The waiting time was already there. I just was not using it.

That led to the idea behind Repset:

What if a completed Codex turn could become a natural moment to move?

I discussed this behavior informally with friends in the same field and major. Several immediately recognized the same pattern: long coding sessions, excitement while waiting for AI output, and very little movement. This was not a formal user study, but it helped me see a credible audience beyond myself.

Repset does not diagnose conditions, provide treatment advice, or promise health outcomes. Its purpose is simpler: help developers notice opportunities for short movement breaks without interrupting their concentration at arbitrary times.

What Repset does

Repset turns natural Codex pauses into short, private, optional movement breaks.

The working product flow is:

Codex turn completes → sanitized local event → optional nudge → movement choice → completion → points → weekly progress → MCP status in Codex

A non-blocking Stop hook notices when a Codex turn completes. Repset then checks coarse local session duration, cooldowns, Snooze state, and the movement context explicitly selected by the user.

Pip—Repset’s original movement-spotter mascot—can then offer:

  • a camera-assisted squat challenge;
  • a standing mobility reset;
  • a seated activity;
  • a quiet or low-impact option;
  • or a camera-free honor-mode alternative.

A nudge may be surfaced at an eligible task boundary, but Repset never starts a challenge, opens a browser, requests camera permission, or blocks Codex without an explicit user action.

Start, Skip, and Snooze remain explicit. There are no hard lockouts, punishment messages, or streak resets. Standing, seated, camera-free, quiet-office, and low-impact choices earn equivalent weekly progress.

Repset also supports user-selected Public, Office, Home, Travel, Seated, Meeting, and Custom contexts. It does not infer location. Meeting mode and an explicit driving or operating-machinery state suppress movement suggestions instead of presenting an inappropriate activity.

After a completed break, Repset updates a local points ledger and a four-day weekly consistency goal. Ledger entries are append-only during normal operation, while an explicit reset remains available for local or demo data.

Back in Codex, the developer can ask:

How is my Repset week going?

Codex calls repset_get_status and reports real local state, including:

  • breaks completed today;
  • active days this week;
  • weekly goal progress;
  • total points;
  • the most recent activity;
  • the next eligible break time;
  • and Sandbox Boost progress.

Compatible Codex hosts can also render Repset’s bundled MCP App card with real local progress, onboarding, Settings, movement choices, Start, Skip, Snooze, and Sandbox actions. When a host does not render MCP App UI, the structured-text workflow remains available through the same MCP tools.

Why it matters

Repset is delivered as a Codex plugin, but its outcome is personal and human.

Agentic coding can reduce the number of natural reasons a developer has to leave the screen. Traditional break timers can interrupt the middle of a productive thought, so they are easy to dismiss. Repset uses an event that already exists—the end of a Codex turn—as a more natural opportunity to offer movement.

The product does not try to force exercise or optimize unlimited repetitions. It rewards weekly consistency, keeps alternatives equivalent, and lets the developer remain in control.

That is why Repset fits Apps for Your Life: the plugin is the delivery mechanism, while the product’s core value is personal movement and everyday wellbeing during AI-assisted work.

Privacy by design

A movement reminder does not need to know what a developer is building.

Repset does not persist or forward:

  • prompts;
  • assistant responses;
  • source code;
  • repository names;
  • paths or filenames;
  • terminal commands;
  • Git diffs;
  • transcripts;
  • or raw Codex session IDs.

Codex lifecycle input is treated as sensitive. The hook uses a strict allowlist and writes only a pseudonymous HMAC-derived session key, a coarse event type, an idempotency key, and a timestamp. Raw identifiers and unrelated lifecycle fields are not included in the stored Repset event.

User-selected preferences, break records, points, and weekly progress are stored locally because they are necessary for the product’s status and consistency features.

Camera permission is requested only after the user presses Use camera. MediaPipe Pose Landmarker runs in a browser worker using bundled model files. Raw camera frames remain in browser memory and are never persisted or uploaded.

Camera denial, unavailable hardware, pose-model failure, reduced-motion preferences, standing alternatives, seated alternatives, and honor mode all retain valid equal-progress completion paths.

Repset requires no account and no mandatory cloud database. Its local service binds to loopback, stores progress in local SQLite, and fails open if unavailable so it never blocks Codex.

How GPT-5.6 is used

GPT-5.6 has one meaningful but deliberately bounded responsibility: rank activities from Repset’s human-reviewed catalog.

The optional model input contains only coarse movement context, such as:

  • continuous-work duration;
  • completed breaks today;
  • available break time;
  • recent catalog activity IDs;
  • weekly progress;
  • the user-selected environment;
  • movement and difficulty preferences;
  • quiet-office requirements;
  • and user-defined movement exclusions.

GPT-5.6 never receives source code, prompts, assistant responses, repository context, or transcript content.

The model must return strict structured output containing:

  • one approved activity ID;
  • a permitted duration;
  • a concise reason;
  • a short coaching message;
  • and up to two approved alternative IDs.

Repset validates the response against the catalog and the user’s current constraints. It rejects invented exercises, unavailable activities, duplicate or disallowed IDs, invalid durations, malformed output, medical language, shame-oriented language, refusals, network failures, and timeouts.

The validated result is normalized into Repset’s stable selected-and-fallback response used by the MCP server and user interface.

If OPENAI_API_KEY is absent—or anything about the model response fails validation—Repset immediately uses its deterministic local selector. The plugin and public judge demo therefore remain fully functional without API access.

GPT-5.6 improves contextual ranking, but it never becomes Repset’s safety authority or a single point of failure.

How I built it

Repset is a TypeScript monorepo composed of five main parts:

  • apps/site — the Next.js product website, no-login judge demo, and optional server-only GPT selector.
  • packages/core — the reviewed activity catalog, schemas, session eligibility, cooldowns, deterministic selection, weekly quest logic, points rules, and squat state machine.
  • packages/local — the authenticated loopback service, local challenge interface, and SQLite persistence.
  • packages/mcp — the stdio MCP server, real Repset actions and status, and bundled MCP App interface.
  • plugins/repset — the production plugin manifest, skill, SessionStart and Stop hooks, MCP configuration, compiled runtime, and branded assets.

The complete implementation connects:

  • trusted Codex lifecycle hooks;
  • a fail-open local handoff;
  • optional first-run onboarding;
  • persistent local settings;
  • a reviewed movement catalog;
  • on-device pose estimation;
  • accessible camera-free alternatives;
  • an append-only points ledger;
  • weekly consistency;
  • bounded GPT-5.6 ranking;
  • deterministic fallback;
  • and real status inside Codex through MCP.

Repset is distributed through a public GitHub-backed Codex marketplace. The tested release is pinned at v0.3.3, so judges can install the plugin without rebuilding the repository.

Judges can also test the main movement experience without an account through the public Repset demo.

The hardest challenges

Turning a personal idea into a real product

The first challenge was making Repset more than a break timer with a different trigger.

I had to define when a nudge should appear, how cooldowns should behave, how long Snooze should last, how to prevent repeated interruptions, and how to make movement feel supportive rather than coercive.

The result is a system built around natural boundaries, visible controls, neutral language, and user choice.

Learning the Codex plugin architecture

Hooks, trust review, MCP servers, bundled skills, local runtime ownership, marketplace packaging, MCP App rendering, and new-task behavior were new territory for me.

Building Repset changed my understanding of Codex. I was no longer only using Codex to create products; I was building a product that lives alongside Codex and responds to its lifecycle.

Protecting developer context

A Codex lifecycle event can contain much more information than Repset needs.

The safest design was not to collect everything and redact it later. Instead, Repset constructs a new minimal event from a strict allowlist before anything is persisted or handed to the local runtime.

Privacy tests deliberately inject prompts, paths, code, commands, diffs, repository information, and transcript locations and verify that these values do not survive sanitization.

Making camera verification forgiving

Human movement and pose inference are noisy.

The squat state machine uses calibration, confidence thresholds, multi-sample confirmation, angle transitions, pose-loss recovery, and rep hysteresis to reduce missed or duplicate counts.

Repset does not grade exercise form, diagnose posture, or withhold equal progress when camera verification is unavailable.

Keeping AI optional

The product had to remain useful without API credentials, network access, or a valid model response.

That requirement produced a deterministic selector that follows the same catalog, context, duration, and exclusion constraints as the GPT-5.6 path. The model can improve ranking, but deterministic code always remains available.

How Codex helped me build it

Codex was my primary engineering collaborator throughout the project.

I used Codex to help:

  • plan the first complete vertical slice;
  • scaffold the TypeScript monorepo;
  • implement and debug lifecycle hooks and MCP tools;
  • build the local runtime, SQLite ledger, and movement systems;
  • develop the squat-verification state machine;
  • create privacy and security tests;
  • improve responsive design and accessibility;
  • package and validate the GitHub marketplace release;
  • prepare technical and submission documentation;
  • and verify the production website and release artifacts.

Codex accelerated the engineering work, but I made the central product and safety decisions:

  • the original problem and natural-boundary insight;
  • the privacy boundary;
  • the human-reviewed activity catalog;
  • equal progress across accessible alternatives;
  • the no-lockout and no-shame principles;
  • Pip’s identity and visual direction;
  • the camera permission model;
  • the points and reward limits;
  • and the final release criteria.

What I learned

My biggest lesson was that a useful AI product does not need to give the model unlimited authority.

GPT-5.6 is valuable in Repset because its responsibility is narrow, structured, and testable. Deterministic code remains responsible for eligibility, catalog restrictions, exclusions, points, weekly progress, validation, and fallback behavior.

I also learned that an agent lifecycle event can support a more humane workflow. A completed Codex turn is not only a technical event; it can also be a natural opportunity to move, look away from the screen, and reset before beginning the next task.

Most importantly, I learned how to take a personal, slightly wild idea and keep testing its boundaries until it became an installable product with real hooks, local state, accessible alternatives, privacy protections, automated tests, a public demo, and a pinned release.

Pip and what’s next

During the project, I also created Pip, an original Repset mascot and optional custom Codex pet.

The optional pet uses Codex’s supported custom-pet format and can reflect the Codex task states Running, Needs input, Ready, and Blocked. This is deliberately separate from Repset’s movement state.

The pet communicates Codex task activity. The Repset plugin independently manages movement eligibility, onboarding, settings, challenges, camera permission, completion, points, and weekly progress.

Pip is not required to use Repset. Custom-pet availability depends on the user’s account, workspace, and supported Codex experience, and installation requires explicit user review. Repset also respects reduced-motion preferences and provides static Pip presentation where animation is inappropriate.

Next, I want to test Repset with more developers, broaden the human-reviewed activity catalog, improve Windows and Linux validation, and learn which natural agent boundaries feel helpful rather than distracting.

I would also like to explore richer Pip interactions while keeping the pet optional, lightweight, and separate from sensitive developer context.

The goal is not to make developers stop using AI tools.

It is to help us take better care of ourselves while we use them.

Move while the model thinks.

Built With

  • codex
  • codex-hooks
  • codex-plugins
  • css
  • github-actions
  • gpt-5.6
  • mediapipe
  • model-context-protocol
  • next.js
  • node.js
  • openai-responses-api
  • playwright
  • pnpm
  • react
  • sqlite
  • svg
  • typescript
  • vercel
  • vitest
  • web-workers
  • zod
Share this project:

Updates