wiki

how to use alibi well

this page is the working manual for alibi: what it is, how the record is built, how to write notes that future-you can actually use, and how to talk to the companion when the day was too tangled for a clean label.

the basic idea

a clean time tracker assumes work is simple: you planned a task, did it, then stopped. alibi assumes the real day is messier. the timestamp matters, but the note is where the useful truth usually lives.

what alibi is

alibi is a witness for lived time. it helps you keep evidence of what actually happened, especially when the day was messy, mixed, or hard to remember clearly.

  • it is not a planner, todo list, scorecard, or productivity dashboard.
  • it records completed time, not expectations.
  • it treats nuanced notes as the most important part of the record.
  • it uses chat to help you reconstruct details, not to judge or push you.

how the system works

the app has three ways to create the same kind of record: timer, manual block, and chat. all three write to the time-block timeline.

  • a time block gives the note coordinates: date, start, end, duration, category, and tags.
  • the note explains what really happened inside that time.
  • the general companion chat can start or stop the timer, add a completed block, or ask for missing details.
  • each completed block can open its own companion thread for reflection about that block.
  • derived insights are stored beside your notes, but they never replace the original text.
  • authenticated accounts also index source-linked memory chunks so later questions can retrieve relevant blocks, notes, insights, and chat turns.

how to write useful notes

a useful note does not need to be tidy. it should preserve the texture of the block so future-you and the agent can understand what the timestamp alone cannot say.

  • write what you intended to do and what actually happened.
  • include parallel activity, attention shifts, interruptions, and useful distractions.
  • name friction: what slowed you down, what you avoided, what felt unclear.
  • include feeling: guilt, relief, pride, flatness, anxiety, satisfaction, or mixed states.
  • record outcome without judging it: what moved, what changed, what became clearer.
  • edit later if your interpretation changes. note history is preserved.

how to make chat useful

chat is best when you use it as a reconstruction partner. ask it to help pull out details, feelings, and patterns instead of only asking it to log a clean task.

  • ask it to help reconstruct a messy block when you remember fragments.
  • ask it to turn a rambling description into a time-block note.
  • use natural duration language: ongoing work starts an open timer in the past, while completed work logs the duration ending now.
  • tell it to ask follow-up questions before saving if task or category evidence is unclear.
  • ask for evidence-backed reflections, such as what your notes show this week.
  • use it when you feel like you did nothing; it can read saved blocks back with specifics.
  • use chat about this on a saved block when you want reflection scoped to one block and its note.
  • use voice when typing is too much: push to talk, stop recording, review the registered transcript, then let it submit through the same companion path.

how retrieval works now

alibi's current memory layer combines deterministic date-scoped SQL context with vector search over source-linked memory chunks. it is retrieval over your saved evidence, not provider-native model memory.

  • default scope is today; language can expand scope to yesterday, the last few days, week, month, or all saved memory.
  • SQL context loads completed blocks, note insights, linked block chat, chat-derived insights, and recent visible messages in the relevant range.
  • vector RAG searches indexed chunks from time blocks, note versions, block insights, companion messages, and companion message insights.
  • retrieval keeps source type, source id, source date, similarity, and chunk metadata so answers can stay tied to dated evidence.
  • when vector retrieval is unavailable or too sparse, alibi falls back to the SQL memory packet rather than inventing a broader story.
  • block-specific chats do not use broad retrieval; they stay scoped to the fixed block context.

dashboard and custom views

the dashboard is a mirror for saved evidence, not a score. it shows aggregate shape, note-grounded observations, chat-grounded language patterns, and fixed-format custom views.

  • built-in dashboard views show totals, category distribution, rhythm, markers, effort, satisfaction, notes mirror, and chat mirror.
  • custom dashboard views start from a user prompt, then alibi drafts a constrained view from server-built dashboard data.
  • custom views can choose from a fixed renderer palette; model output cannot run arbitrary queries or introduce unsupported UI.
  • custom view results should use supplied evidence references, excerpts, and source-backed claims.
  • voice capture is available in custom-view prompt fields and inserts transcribed text instead of auto-submitting the form.

calendar, sync, and voice

alibi now has account features beyond the tracker: a calendar workspace, optional Google Calendar sync, BYOK model settings, and Cartesia voice surfaces.

  • the calendar route pairs a compact month view with a selected-day timeline and inline block detail panel.
  • chat about this works from calendar-selected blocks and returns to the same block-specific companion thread.
  • Google sync creates a separate user-owned alibi calendar and writes completed blocks as events when connected.
  • save, edit, and delete operations attempt to sync or delete matching Google events; the calendar page includes manual retry controls.
  • Cartesia STT/TTS supports batch push-to-talk input and optional spoken companion replies. raw browser audio is sent for transcription and is not stored by default.
  • the demo previews the workspace locally, but full RAG indexing, retrieval logs, BYOK storage, and Google sync require an authenticated account.

general chat vs block chats

alibi now keeps the main companion chat separate from block-specific threads. the main chat can operate the timer and log blocks. a block thread is reflective: it stays focused on one saved block.

  • open a block thread from the message button on a completed time block.
  • opening the same block again returns to the same thread instead of starting over.
  • the block note is included as fixed context, so the companion can discuss what actually happened inside that block.
  • block threads can summarize, reframe, and help you reinterpret the block, but they do not edit stored data in this version.
  • use main chat when you want to log new work, start or stop the timer, or ask about the whole day.

how insights should be read

insights are interpretations of your evidence. they are useful for pattern spotting, but the raw note and chat history remain the source of truth.

  • the strongest evidence is a note tied to a dated time block.
  • metadata like category, duration, mood, effort, and tags adds context.
  • block-specific companion threads can explain feelings or missing details around a block.
  • the notes mirror shows what happened inside saved blocks; the chat mirror shows patterns in how you describe the day.
  • chat-derived insights can surface intention, avoidance, useful drift, mismatch, and feeling language without turning every message into a block.
  • retrieved chunks are supporting evidence, not a replacement for the original block, note, or message.
  • good observations should point back to dates, blocks, excerpts, or messages.

privacy and data

your timeline is stored in your own authenticated account. the app keeps raw input and derived interpretation separate so your words remain intact.

  • row-level security protects time blocks, active timer state, categories, note versions, insights, and chat messages.
  • timer, manual entry, and chat share the same time-block data structure.
  • companion conversations keep general chat separate from block-specific chats.
  • block chats store compact block context so the agent can use the note without loading unrelated history.
  • note versions preserve meaningful edits instead of silently losing the old version.
  • retrieval uses source-linked records and memory chunks; observations should stay tied to dated blocks, excerpts, or messages.

ai models, providers, and cost

alibi runs on two model slots. a fast slot handles routing, extraction, and acknowledgments. a companion slot writes the voice that talks back. you can keep the hosted defaults or bring your own keys from /app/settings.

  • hosted default fast model is deepseek chat v3. it classifies what you typed and pulls structured fields like time and category.
  • hosted default companion model is anthropic claude haiku 4.5. it writes the reply and matches the alibi voice guide.
  • non-visible work like chat-insight and note-insight extraction runs on the fast model so the bill stays small. custom dashboards use the companion model internally to analyze a server-built evidence packet.
  • chat-insight and note-insight extraction run inline on the fast model so derived mirrors stay reliable after each saved message or note.
  • the analyse path uses the fast model to gather evidence from the memory packet, then the companion model rewrites only that summary in the alibi voice. the long evidence packet never pays companion-tier price.
  • the vector RAG layer currently uses server-owned OpenAI embeddings for memory chunks; chat generation can still use hosted defaults or your selected BYOK provider.
  • on direct anthropic profiles, the system prompt and voice guide are sent with ephemeral prompt caching, so repeat turns bill cached input at a fraction of the normal rate.
  • settings ships presets for openrouter, openai, anthropic, deepseek, qwen (dashscope), zhipu glm, and moonshot kimi. any openai-compatible base url also works, including a local llama.cpp or vllm server.
  • your provider key is encrypted at rest and is only used in the request that needs it. nothing about your messages is shared with alibi infrastructure beyond that request.

note and chat examples

useful note shapes

quick version

meant to answer email, got pulled into fixing the gallery upload bug. useful detour, but i felt guilty because the invoice is still open.

reflection version

started with admin. avoided the invoice for about 15 minutes by cleaning up tabs, then actually found the missing receipt. felt scattered but less stuck after that.

parallel activity version

had the meeting on in the background while editing the proposal. mostly proposal work, but the meeting gave me two useful phrasing changes. energy was low but focus improved near the end.

prompts for main chat

  • help me reconstruct the last two hours before you save anything.
  • ask me questions to turn this into a useful note: i bounced between the invoice and gallery bug.
  • log a block from 2 to 3:15, but help me name what actually happened.
  • i've been doing email for 30 minutes.
  • i did email for 30 minutes.
  • what do my notes this week suggest about when admin turns into avoidance?
  • look across all saved memory: where does useful drift show up?
  • i feel like i did nothing today. can you read back the evidence from my blocks?
  • turn this messy description into a note, and keep the uncertainty in it.

prompts for chat about this

  • what does this note say that the task name misses?
  • help me name the actual work inside this block.
  • summarize this block without making it sound cleaner than it was.
  • what friction shows up here?
  • what should future-me remember about this block?

where this is going

alibi now has the first retrieval layer: SQL range context plus source-linked memory chunks from blocks, notes, insights, and companion messages. the next version should make that layer more reliable around timezone scopes, fallback filtering, and longer notes while keeping every observation connected to dated evidence.

better notes

support richer reflection without forcing a form: intended versus actual, attention shifts, friction, feeling, and outcome.

better evidence

extract small source-linked claims from notes and chat so every pattern can point back to what you wrote.

better retrieval

tighten source and date scoping so vector fallback never widens a question beyond the evidence the user asked for.

start with one honest block. messy is useful.

try the democreate account