Project Info

FocusForge

Inspiration

We built FocusForge because we kept running into the same problem: real work on Chrome turns into dozens of tabs across docs, videos, code, tickets, and references. After a break—or even the next day—you don’t just forget which tab to open. You forget the context: what mattered, where you left off, and what to do next. Reconstructing that mental state wastes time and kills momentum. For a student, it’s the classic spiral: you’re researching for an assignment, watching one “helpful” video, cross-checking notes, opening a reference paper, and suddenly your browser is a wall of tabs. You step away for dinner, come back, and spend the first 10 minutes just trying to remember what you were even doing—while the deadline is still the same. For a working professional, it’s even worse. Work is never one thing at a time: Slack pings, meetings, tickets, dashboards, internal docs, PR reviews, and random “quick checks” that hijack your flow. You might be productive for an hour, but later you can’t answer the simplest question: What did I actually make progress on, and what’s the next step? And for everyone—students, employees, creators—Chrome becomes a messy memory dump. You keep tabs open because you’re afraid you’ll lose something important. You close them and regret it later. Either way, your brain ends up doing the work a tool should do: rebuilding context from scratch every time you restart. We wanted a way to “pause life” and then resume instantly—so instead of re-orienting yourself manually, you can come back and immediately see what mattered, what you touched, and what to do next.

What it does

FocusForge helps you resume faster when you’ve lost track. You start a focus session from our Chrome extension, and FocusForge tracks your browsing activity in a privacy-safe way—only URL, page title, and timestamps (no page content, no keystrokes). When you stop the session, FocusForge generates a Session Resume that brings your context back in seconds: Last Stop: the exact page you ended on, so you can jump back immediately Workspaces: where you actually spent time (top sites/domains), so you know what mattered Timeline: a clean trace of what you touched and when, so the session is reconstructable AI Resume + Next Steps: a grounded recap and actionable steps to continue without rethinking You can create multiple sessions so each workflow—coding, job search, studying, creative work, admin tasks—stays separated and easy to pick back up later. To make the session truly persistent, you can also export the full resume to an Opennote Journal, turning each session into a searchable, organized note you can revisit anytime.

How we built it

e designed FocusForge as a simple loop: capture → store → summarize → resume → export. Chrome Extension (tracking layer) Starts/stops focus sessions and logs tab activity in real time (URL, title, timestamps). This is how we capture “what happened” without reading page content. Backend API (session controller) Receives session + event logs, handles session lifecycle (start/stop/idle), and exposes endpoints to fetch recent sessions and session details for the UI. Supabase (Postgres database) Stores session metadata and the event timeline (sessions + session_events + analysis output). This makes sessions persistent, searchable, and demo-stable. AI Summary (Gemini) Converts the session trace into a grounded “Session Resume” and next-step suggestions—based on captured URLs/titles, not page content. Web App UI (Figma → implementation) A dashboard for recent sessions and a Resume Panel that surfaces the most important context quickly (last stop, workspaces, timeline, recap). Opennote API Integration Exports the final Session Resume into an Opennote Journal so the recap becomes a clean, persistent note you can revisit and build on.

Challenges we ran into

Integrating Opennote cleanly and formatting exports so they look polished and useful. Integrating Opennote cleanly and formatting exports so they look polished and useful. Keeping scope focused: avoiding feature bloat and staying centered on “resume where you left off.” Keeping scope focused: avoiding feature bloat and staying centered on “resume where you left off.” Demo stability: making sure sessions/events/summaries don’t break with edge cases under time pressure. Demo stability: making sure sessions/events/summaries don’t break with edge cases under time pressure. Defining “focus” without being invasive: We wanted meaningful insights while staying privacy-safe (no page content/keystrokes), so we had to make summaries and intent alignment work using only URLs/titles/timestamps. Defining “focus” without being invasive: We wanted meaningful insights while staying privacy-safe (no page content/keystrokes), so we had to make summaries and intent alignment work using only URLs/titles/timestamps. Reliable session boundaries: Handling real-life behavior like idle time, laptop sleep, and accidental “leave session running” cases without corrupting the timeline or breaking demo flow. Reliable session boundaries: Handling real-life behavior like idle time, laptop sleep, and accidental “leave session running” cases without corrupting the timeline or breaking demo flow. Consistency across components: Keeping the extension, backend, database, and web UI in sync so session IDs, events, and summaries always match—even when users refresh or restart. Consistency across components: Keeping the extension, backend, database, and web UI in sync so session IDs, events, and summaries always match—even when users refresh or restart. Making AI outputs trustworthy: Preventing “hallucinated” summaries and ensuring the recap stays grounded in what actually happened during the session. Making AI outputs trustworthy: Preventing “hallucinated” summaries and ensuring the recap stays grounded in what actually happened during the session. Turning raw events into useful structure: Converting messy tab-switch logs into “workspaces,” time breakdowns, and a readable timeline that feels instantly understandable. Turning raw events into useful structure: Converting messy tab-switch logs into “workspaces,” time breakdowns, and a readable timeline that feels instantly understandable. Last-minute polish without breaking core: Improving UI/UX while avoiding risky refactors that could destabilize tracking or exports right before demo. Last-minute polish without breaking core: Improving UI/UX while avoiding risky refactors that could destabilize tracking or exports right before demo.

Accomplishments we're proud of

Izzy: I'm proud of the hover effects I added to the buttons to make using the interface more fun. I also added the graphs to the Resume Panel which I think helps the user look over their stats more. Nikitha: I'm proud of building apps in html/css/js to working with APIs and implementing a supabase backend to persist session, event, and analysis data for a chrome extension MVP. Sakshi - Im proud of building the project skeleton + backend pipeline (sessions/events → Supabase) so the core loop is stable and demo-ready. I Implemented session lifecycle logic (start/stop + inactivity handling) to match real user behavior without corrupting timelines. I also Integrated Opennote export, turning each Session Resume into a clean, structured journal entry you can revisit later and kept the system reliable under demo pressure by prioritizing stability and edge-case handling over risky last-minute features.

What we learned

Nikitha: As a first-time hacker, I learned a lot of things. I learned how to build and ship a product under time constraints. I learned how to turn a prototype into a stable, demo-ready backend and gained experience in designing a reliable database schema. I also learned how to use a modern backend platform instead of building everything from scratch by using supabase as a managed backend and connecting frontend to backend through APIs. Sakshi - I learned how to design an event-based session model (sessions + session_events + analysis) so raw tab pings can later be reconstructed into a timeline/workspaces without losing integrity. I also learned that productivity apps live or die on session boundaries—handling inactivity, laptop sleep, and accidental long-running sessions needs clear rules + consistent behavior across all endpoints. I learned how to build integration-safe exports: converting internal JSON into a clean, structured Opennote journal template that stays readable and doesn’t break when fields are missing.

What's next

Better AI summaries UX improvements Build a personalized intent model: App stores and learns the user's definition of focus and their repeated workflows Add automatic task extraction and execution tracking: Detects todos, schedules them and check for completion in the next session Cross-device continuity: You stop on laptop, resume on phone with the same context and "next step". Personalized intent model: learn each user’s definition of “focus” over time (their common workflows + what they consider distraction) and adapt alignment scoring accordingly. Smarter “Resume Session”: restore a full workspace (top tabs/domains) instead of only the last stop, so users can truly continue in one click. Action tracking across sessions: extract next actions, let users mark them done, and show “carried-over tasks” when they resume later. Better Opennote integration: auto-journal on session end + daily/weekly rollups inside Opennote (sessions grouped, searchable, and reviewable).

FocusForge

Resume work without rethinking.

FocusForge preserves intent and decision context across browser sessions so you can resume meaningful work instantly. It is not a task manager, not a note app, and not a productivity tracker. It is intent memory.

Problem

When people return to work, their files are still open but their thinking is gone. Re-orienting costs 10 to 20 minutes per session. Existing tools preserve content, not decision context.

What FocusForge Is / Is Not

FocusForge is:

A session-based intent memory
A system that extracts next actions and decisions
A way to resume work without cognitive reload

FocusForge is not:

A task manager
A note app
A productivity tracker or habit app
A ChatGPT wrapper

Core User Flow

Start a focus session (enter a goal).
Auto-capture lightweight context (active tab URL, title, timestamps).
End session and run analysis (next actions, decisions, resume summary).
Resume session on one clean screen (goal, actions, decisions, grouped links).

Key Differentiators

Intent memory: "You were drafting a resume bullet for backend roles."
Decision awareness: "Need to decide whether to apply via referral."
Cognitive compression: one goal, 3 to 5 actions, grouped links.

Privacy Stance

Only active tab URL + title + timestamps.
No page content, no keystrokes.
Pause/Resume anytime.

Architecture (High Level)

Chrome Extension (MV3) -> Next.js API -> Supabase -> Analysis -> UI

The extension sends tab activation events. The app computes durations, groups workspaces, and calls an LLM to generate next actions, pending decisions, and a resume summary.

Data Model

Session

{
  "id": "uuid",
  "goal": "Apply to SWE roles",
  "started_at": "...",
  "ended_at": "...",
  "raw_context": "...",
  "resume_summary": "...",
  "next_actions": [],
  "pending_decisions": [],
  "link_groups": []
}

Event payload (from extension)

{
  "sessionId": "uuid",
  "ts": 1730000000000,
  "type": "TAB_ACTIVE",
  "url": "https://leetcode.com/problems/two-sum",
  "title": "Two Sum - LeetCode"
}

API Endpoints

POST /api/session/start -> { sessionId }
POST /api/event -> stores activity events
POST /api/session/pause / /api/session/resume
POST /api/session/end -> triggers analysis
GET /api/session/:id -> session + analysis + timeline
POST /api/opennote/journal/export -> optional journal export

Analysis Pipeline

Deterministic summary:
- Sort events, compute duration per tab
- Extract domains
- Aggregate workspaces and top URLs
- Identify last stop
LLM enrichment:
- Resume summary (1 to 2 sentences)
- Next actions (3 to 5, verb-leading)
- Pending decisions (1 to 3)

UI Screens

/ Dashboard (recent sessions, open session, demo)
/session/[id] Resume screen (main demo view)
/session/demo Demo fallback
/session/live Live session view

Repo Structure

app/ Next.js App Router UI + API routes
lib/ Analysis, grouping, and data helpers
extension/ Chrome extension (MV3) that sends events
backend/ Legacy Pages Router API (kept for reference)
public/ Static assets

Getting Started

Prereqs

Node 18+
Supabase project (or local fallback)
Optional: Opennote API key for journal export

Install

npm install

Environment

Create .env.local in the project root:

NEXT_PUBLIC_SUPABASE_URL=...
NEXT_PUBLIC_SUPABASE_ANON_KEY=...
SUPABASE_SERVICE_ROLE_KEY=...
OPENNOTE_API_KEY=... (optional)

See ENV_SETUP.md for details.

Run

npm run dev

Open http://localhost:3000.

Chrome Extension (MV3)

Open Chrome -> Extensions -> Enable Developer mode.
Load unpacked -> select extension/.
In the popup, set intent and start session.
Browse normally; events are posted to the web app.

The extension defaults to http://localhost:3000 and auto-detects Vercel domains when available.

Deployment

Deploy with Vercel.
Ensure env vars are set in the Vercel project.

Demo Tips

Preload 2 to 3 sessions (job apps, interview prep, hackathon planning).
Show messy browsing, end session, then open resume screen instantly.
Use the "resume summary" line: "Last time, you were working on X..."

Non-Negotiables

Keep scope tight
Do not add features outside intent memory
UI must feel finished
Demo must be instant

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

CSSIn code
HTMLIn code
JavaScriptIn code
Next.jsIn code
PythonIn code
ReactIn code
SQLIn code
SupabaseIn code
Tailwind CSSIn code
TypeScriptIn code
Google GeminiClaimed
VercelClaimed

10 of 12 appear in the indexed code. 2 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

No AI coding agent signals were found in this repository.

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

463 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.

FocusForge

Inspiration

What it does

How we built it

Challenges we ran into

Accomplishments we're proud of

What we learned

What's next

FocusForge

Problem

What FocusForge Is / Is Not

Core User Flow

Key Differentiators

Privacy Stance

Architecture (High Level)

Data Model

API Endpoints

Analysis Pipeline

UI Screens

Repo Structure

Getting Started

Prereqs

Install

Environment

Run

Chrome Extension (MV3)

Deployment

Demo Tips

Non-Negotiables

Technology

AI coding agents

Codebase size

Structure

Interface

API & routing

Application logic

Data & schema

Languages

Dependencies