AriCore v0.4.1 → v0.4.3 — Studying, and Dreaming

The v0.4 line gives AriCore two new things to do — one during the day, one overnight.

The daytime piece is Study. A new top-level tab where you tell Ari what you want to learn and how much time per day you've got. It designs a curriculum, generates a lesson at a time, quizzes you, runs midpoint and final exams. Finish and you get a framed certificate plus a one-tap PDF workbook of everything you did.

The overnight piece is Dreams. The assistant reads recent conversations while the device is plugged in and idle, reflects on what it learned about you, and gathers proposals for the morning: memories worth keeping, custom skills you'd actually use, persona suggestions, watchers for things you care about. Nothing applies automatically — every proposal goes through your review.

The features landed across three point releases — v0.4.1 introduced both (Study + the Dreams pipeline), v0.4.2 added Study's workbook export and post-completion branching, v0.4.3 brought certificates and Dreams' painted visual identity. Here's the whole picture.

Study with Ari

Tap the + on the Study screen and you get a short form: topic, goal, daily minutes (5/10/20/30), course length (12/21/42/90 days), prior knowledge. That's the whole input. There's no chat with Ari to negotiate the curriculum, no model-spawning round trip — the form is the contract.

From those inputs Ari designs a curriculum spine: an ordered list of modules with named concepts. The spine isn't a fixed lesson plan — it's the destination arc. Lessons themselves are generated session-by-session, informed by how your previous quizzes went, which flashcards you're failing, and what you've actually got time for today. A 21-day × 30-min bootcamp produces substantially more material per session than a 21-day × 5-min overview, and the lesson-volume rules in the generator know the difference between "you'll have heard of X" and "you can independently work with X".

What a session looks like

A regular session has, at minimum, a lesson (markdown-rendered, sized to the day's budget) and a quiz (multi-choice, four options each, topic-tagged so weak topics get woven back into upcoming lessons). On top of that, the model can include:

• Free response — a written-answer prompt with a rubric. You write a paragraph; the tutor grades it with prose feedback when the lesson finalizes.
• Cloze — fill-in-the-blank passages. Particularly good for language and key-term recall; checked locally, no LLM round trip.
• Code exercise — on programming courses. Specifies language, starter code, and a rubric the tutor evaluates against. Your submission gets a per-rubric grade and a written critique.

The trick we learned the hard way: each activity is "lock in" rather than "submit". You answer, you tap LOCK IN ANSWER (or CHECK on cloze), the card freezes. The lesson stays open. The lesson body is right there if you want to glance back. Quiz feedback stays visible per-question. When you're done with everything, COMPLETE LESSON at the bottom commits the whole thing in one shot — quiz is persisted, written and code answers are graded by the tutor in the background, and the screen flips to a post-completion view with a soft grading shimmer until the marks land.

Exams

At the spine's midpoint a midpoint exam fires automatically, cumulative on everything taught up to that point. Multi-choice plus free-response, with the tutor writing prose feedback on the writing answers. Pass at 70% to continue.

At the end of the course, the final exam. Same format, same threshold. Pass and the course is marked complete.

Fail an exam and you get a fail grade plus an option to extend: the tutor identifies the weak topics from your answers and generates a focused remediation arc — typically 5 extra sessions for the midpoint, 8 for the final — emphasising exactly what you got wrong, before you retry the exam.

The tutor stays out of your life

Every course has its own chat — tap Chat with your tutor on the course screen to ask about the lesson. Tutors are not personas. They live in the Study tab, can't be selected from the persona picker, and have a hard wall around your personal context:

• No tools — tutors can't browse the web, can't read your calendar, can't write memories.
• No assistant-context block — they don't see the date/weather/calendar/last-thread injection that goes into your daily chats.
• No memory writes — nothing tutors learn about you persists.
• No appearance on the home screen — tutor chats don't pollute the threads list.
• Not included in dreams — the dream pipeline excludes course threads when it gathers conversations to reflect on.

If you ask your Italian tutor "what's on my calendar tomorrow?", it answers like a tutor would: don't worry about that now, we'll get to it tomorrow.

Workbook export

Finish a course and the completion screen offers EXPORT WORKBOOK AS PDF. One tap renders the whole thing — cover page with goal and date and final grade, the curriculum spine, every session in order (lesson body, your quiz with answers shaded green/red, your locked written-answer and code submissions with the tutor's per-rubric grade and critique), and the exam results.

The PDF is styled in AriCore's warm-cream palette — serif italic for titles, system serif for prose, monospace for code blocks, accent gold for headings and dividers. Header strip on every page with the course name; footer with the page count. iOS share sheet handles the rest: save to Files, AirDrop, mail it to yourself.

Certificates

When you complete a course, the post-completion screen now leads with a framed certificate: a cream plaque with a double gold border, ornament strips top and bottom, the course name in big serif italic, a wax-seal medallion holding your final-exam grade letter, the score, and the date awarded. It springs in on first view with a soft scale + fade. Re-opening the completed course replays the reveal — you get the moment again every time.

The completed-courses shelf

Completed courses don't disappear. There's a Completed section at the bottom of the Study tab — every finished course as a slightly muted row showing the course name, final grade, lesson count. Tap any of them to re-open the certificate page and the PDF export. Useful because:

• You can re-export the workbook later, after deciding you want to save it somewhere different.
• You can branch into a follow-up course from any prior finish, not just the most recent one.
• It's a record. Seventeen short courses on different topics is a different thing to have on your phone than nothing.

Branching

The course-complete screen has two feedback fields: what did you struggle with most? and what did you want more of? Optional. Tap SUGGEST NEXT COURSE and the tutor proposes a logical follow-up — topic, two-or-three-sentence pitch, suggested daily-minutes and duration. If you accept, the new course is created with the old course wired in as a prerequisite: the spine generator sees what was already covered and explicitly doesn't re-teach it. Your written feedback also threads through — saying you struggled with verb conjugation shapes the early modules of the next course.

Background generation, plugged-in

The unglamorous infrastructure that makes the daily cadence work: next lessons are pre-generated overnight, while the device is plugged in and charging, via an iOS background task gated on external power. You finish today's lesson, mark it complete, the post-completion footer reads "We'll prep your next lesson while your phone is plugged in tonight — it'll be ready when you wake up." iOS dispatches the task whenever the constraint is satisfied, the runtime walks every active course that has no queued session and generates one, then re-arms itself for the next cycle.

If you can't wait for the overnight bake, the same screen has a BEGIN NEXT SESSION NOW button that triggers live generation right there. iOS gives foreground-launched tasks a short grace window in the background; we wrap generation in it so a quick backgrounding doesn't kill the call. If iOS reclaims the slot before generation finishes, the work is cancelled cleanly and the flag clears so you get a retry button instead of a wedged spinner.

Dreams

The other half of v0.4 is a feature that runs when you're not using the phone. While the device is plugged in and idle, AriCore reads recent conversations, reflects on what it learned about you, and gathers proposals — small concrete things it thinks the assistant should know, or do, or become, that you might want to act on tomorrow.

It's deliberately not a "summary" feature. The output isn't text you read — it's a set of cards you decide on.

Four kinds of proposal

• Memories — one-line facts the assistant should remember about you. "User runs an indie iOS studio, prefers Swift, dislikes Storyboards." Sourced from things you actually said this week, not invented context.
• Skills — small custom tools the model could call. A skill is markdown plus a tiny JSON config; if the assistant noticed you ask the same kind of question every Tuesday, it might propose a tool that just does it. You approve, and Ari generates the skill code — in an isolated context with zero personal data in scope, so the generated code can't accidentally leak your conversations.
• Personas — a new persona drafted around a topic you keep returning to. If the assistant notices you keep starting cooking conversations, it might propose a "Kitchen" persona with its own memory bank and tools, so the recipe chats don't sit alongside the work threads.
• Watchers — background prompts that fire when conditions you care about are met. The dream might propose "ping me if a calendar event is added with 'flight' in the title" — you approve it, and from then on Ari watches.

The dream card

A pinned card at the top of the threads screen surfaces the dream feature in three states:

• Ready — in the evening or on first use, a "Time to dream" CTA with the conversation count.
• Running — a progress strip with the persona-being-reflected-on, plus a cancel button.
• Review — a count of proposals waiting for you, with a tap to open the full report.

The full report groups proposals by confidence bucket. Approve, reject, or edit each one. Reject and it disappears. Approve a memory and it's written immediately; approve a skill and the isolated-context generator kicks off; approve a persona and you can review the drafted prompt; approve a watcher and the trigger is armed. Persistent across launches — close the app mid-review and pick it up the next morning.

What dreams don't see

By design, dreams stay out of a few places:

• Course tutor chats are excluded from the conversation set the dream pipeline gathers. The assistant won't propose memories sourced from your Italian-grammar lesson.
• Personal context never enters the skill creator. When a proposal becomes generated code, the model that writes it runs in an isolated context with no memories, no personas, no thread history. Skills can't accidentally bake your data into their source.
• Nothing applies silently. Every proposal — even high-confidence ones — needs your tap.

The dream sky

In v0.4.3 the feature also got its own visual identity. The dream card on the threads screen and the full dream report sheet both layer a painted night-sky background: deep violet, a crescent moon, concentric orbital rings around a glowing sun, clouds parting around the horizon, mountain silhouettes, a reflective body of water at the bottom. White serif headline and mono caption sit over a soft dark gradient so legibility holds regardless of where the cloud highlights land. The wax-disc medallion that holds the certificate's grade letter and the dream avatar are visually paired — concentric gold rings on a cream disc — so Study and Dreams feel like two surfaces of the same object.

Reliability work

A lot of v0.4.3 is the work that makes "your tutor is generating your next lesson" stop being a maybe.

• Heartbeat-based stuck detection — the pipeline pings the store on every LLM stream chunk. If the heartbeat goes silent for too long, the "Generating…" placeholder flags itself stuck and offers a one-tap retry. Not a wall-clock timer; a real "the model isn't actually generating" signal.
• Background-task cancellation propagates — when iOS reclaims a background slot, the wrapper now cancels the inner work. The deferred cleanup runs, the "generating" flag clears, and you don't come back to find a phantom spinner that never resolves.
• Exam scheduling rewritten — the midpoint exam fires at half the spine's session count, the final at the end. Existing courses get the fix without rebuilding; a long-press on the curriculum card also offers a manual override for tightening an in-progress course.
• Ghost activities filtered — if the model emits a free-response, cloze or code block as a placeholder when it didn't intend to actually use one, the UI no longer renders a dead card you can't dismiss.

What's next

v0.4.3 is in review. The shape of v0.5 is taking form around better tools for the tutor — a focused review session built around the flashcards you keep failing, optional speech-driven cloze for language courses, and a tutor mode that lets you have a Socratic back-and-forth on a topic outside the structured lesson flow. We're also looking at exporting a course as a sharable bundle — drop a .arikit file into someone else's AriCore and they get a runnable course on the same topic, with their own prior knowledge re-baselining the spine.