DEV Community: Abhinav Sankarshana Dasu

haunt: the ghost in your git history — a local Gemma 2 whisper for your repo's graveyard

Abhinav Sankarshana Dasu — Sat, 31 Oct 2026 09:13:13 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

What I Built

Every repository is quietly becoming a graveyard. Files nobody remembers writing. Tests nobody dares delete. TODOs aging like gravestones.

haunt is a ghost for that graveyard — and it lives in git, not in a terminal pasted on top. Two small rituals, entirely offline:

pip install .          # then, inside any git repository:
haunt install          # the whisper joins your post-commit hook
git commit -m "tomb, again"
#   🕯️ Ah, the echoes of lost brilliance in those dusty files, a symphony of
#      potential forever unplayed. The phantom hand of progress reaches out
#      to erase... but will it leave behind anything but shadows?

haunt scan             # which files are the most haunted, and why
haunt report --html    # a narrated HAUNTINGS.md of the worst hauntings
haunt persona ancestor # swap the voice: victorian, poltergeist, ancestor

Three design choices make it a ghost in the machine rather than an AI plugin:

The deterministic score comes first. Every tracked file gets a haunting score computed from git log alone — no model, fully explainable:

   dormant  = min(age_days/365, 1) × min(size/500, 1)        (w 0.35)
   restless = min(churn_90d/20, 1)                            (w 0.25)
   orphaned = 1 if every author inactive 180d+                (w 0.25)
   debt     = min((TODO FIXME HACK XXX)/10, 1)               (w 0.15)

Scores name their ghosts: 🫥 Orphan spirit (all authors gone), 🕸️ Sleeper (old, quiet), ⚡ Poltergeist (high churn, many hands, no owner), 🕯️ Revenant (dormant for months, then suddenly touched).

The model only narrates; it never reads your code. Gemma 2 2B (open weights, via Ollama) receives metrics and commit subjects — never source files (send_snippets is off by default). A 2B model can't review code, so haunt never asks it to. It asks for what a 2B model is actually good at: voice.
The whispers never block a commit. One generate attempt inside a time budget; if the model is cold, busy, or absent, a deterministic template keyed to the commit hash takes over — same commit, same line, forever. No retries, no queues. The hook always exits 0.

The demo (all captured live, CPU-only laptop, today)

haunt scan on pallets/click — a 14-year-old, very-much-alive open-source CLI library — finds 175 haunted files. The top haunting:

score   type             age    churn90  authors  debt  loc  file
0.59    🫥 Orphan spirit  354d   0        0/13     0     782  tests/test_context.py

Thirteen authors. All of them inactive. 354 days without a commit. The file has a funeral attended by no one. The full tally: 84 orphan spirits, 81 sleepers, 10 poltergeists — a repo at rest that nobody would call haunted until you read the blame.

And with the ancestor persona — built for Día de los Muertos, the week's truth that this Halloween stretch is also about honoring the past:

🪔 "Their efforts bring warmth and joy to these old halls. May their spirits find solace in the stories shared through this code."

The poltergeist handles the noisy places:

⚡ "More flickering, more ghosts. Just don't break a fingernail."

Graceful degradation, demonstrated by literally killing Ollama mid-session and committing:

🕯️ A chill passes through the repository. The commit is buried without ceremony.

Same line twice, deterministically keyed to the commit hash — and the hook cost the commit nothing.

And when the report narrates with Gemma — here is haunt's HAUNTINGS.md on that same repo, Victorians mourning real files:

age 354d | churn90 0 | authors 0/13 | TODO/FIXME 0 | 782 loc

"The pages flutter, whispering tales of what could have been. An echo of promises left unfulfilled, a spectral symphony in the grand ballroom of code. Time slips away like dust, leaving only emptiness where brilliance once resided. Give this ghost a purpose: delete, add a test, document it, or assign an owner to finally give it meaning, however fleeting."

The model honestly ends with what the metrics justify — every narration closes with a grounded directive, not vibes. On a lonely orphaned doc it got almost tender:

"Dust motes dance in the flickering light, each one a memory of a lost chapter, a discarded dream. So many stories whispered between lines of code, now gathering dust like forgotten souls. A quiet voice asks: 'Shall I erase its echo or preserve its fragile remnants?' Name an owner for this forlorn document; at least grant it some solace."

How I Built It

Python 3.13, typer, httpx, and raw git subprocesses. No GitPython, no LLM framework. The repo is here; MIT licensed; 24 tests pass, including a test that runs a real git commit end-to-end through the installed hook and asserts the whisper appears.

One-pass history. A single git log --format=<sep>%H<sep>%at<sep>%an<sep>%s<sep> --name-only feeds the entire scanner — records joined on \x1e/\x1f unit separators. Small saga: Python's str.splitlines() will eat your \x1e as a line boundary and silently shred every record; split("\n") keeps the ghosts intact.
Gemma 2 2B with intent. num_ctx pinned at 4096 — Ollama's silent default of 2048 clips the persona+stats prompt without telling you. keep_alive=30m and an install-time warm-up so the first whisper fits its budget.
Idempotent hook surgery. haunt install writes a marker block (>>> HAUNT BEGIN … <<< HAUNT END) with an absolute interpreter path and a PYTHONPATH fallback to python -m haunt — the hook works in any repo without pip install — and backs up any existing hook it finds.
Classification precedence found by tests, not vibes. My first rule made Sleeper unreachable: any file old enough was already an orphan. Ship order is Orphan → Revenant → Poltergeist → Sleeper, with Sleeper firing at ~90 days quiet while its author is still around — the exact limbo of files everyone assumes someone else maintains.

Three posts from the community shaped these calls: @enjoy_kumawat's install-and-timeout postmortems (hooks that "ran" but never actually run), @lowspecai and @studiomeyer_io on what local inference really costs on CPU, and @bartrozycki on how retries and fallbacks compound into their own failure mode — which is why haunt has exactly one attempt and one fallback, no interaction between them.

Then reality kept the honesty flowing:

My 8-second whisper budget was a siren song. Measured cold truth: gemma2:2b decodes at ~5.4 tok/s on this CPU-only machine, so a 100-token whisper is ~18 seconds — the whisper path was unreachable, always falling back. Defaults are now 25s/100 tokens, tuned to the lane the benchmarks above predicted.
The probe gate did more harm than silence. A 2-second "is Ollama alive" check flaked precisely when the server was busy decoding, silently downgrading real whispers to templates. Removed — generation carries its own timeout; the fallback covers everything.
Emoji left silently. On Windows' default cp1252 pipes, persona emoji raised UnicodeEncodeError inside the never-fail-a-commit catch-all — the line simply vanished. The CLI now bootstraps UTF-8 at startup.
And while writing this post, a commit ran while the model was busy narrating a report in the background — the whisper fell back to its template and the commit succeeded instantly. That's the contract working, not failing.

Why Open Innovation Matters

Haunt's premise is that an AI reads your private diffs to comment on them. Closed models make that premise toxic: your repo's history would live in someone else's logs forever. With Gemma's open weights on-device, the only witness is a ghost, and it never leaves your machine.

It works with the lights off. Airplane mode, airgapped CI, a hotel with one dead outlet — haunt doesn't care; nothing in the pipeline calls home.
Zero marginal cost makes it a habit. A whisper on every commit is viable only when inference is free. Gate every commit behind a $0.002 API bill and the ghost becomes a toy you disable in week one.
The haunting can outlive the tool. 1.6 GB — one ollama pull gemma2:2b — and any other Ollama model slots in via one config line. Personas are TOML files; localize the ancestor voice for your team's history. And the fallback templates are auditable, first-party Python — even "no model" is an inspectable code path here.

That last point is the open story in miniature: when the proprietary link dies, dignity dies with it. When the open link dies, you still get a whisper, just a quieter one.

Honest Limits

CPU-only whisper takes ~18s; report narrations (~260 tokens) up to a minute each. Fine off to the side, too slow to be chatty.
The score is a heuristic, not truth — churn isn't ghostliness. Every row prints its own metrics so you can argue with the ghost.
Shallow clones thin out age and author data; haunt still scores, just blunter.
Next up: a pre-push "last rites" summary, blame-aware ancestor naming (opt-in), and a GitHub Action.

The repository is never truly empty. It is merely quiet. 🪦

sloth-tidy: the file organizer that files like you — and never repeats a mistake

Abhinav Sankarshana Dasu — Thu, 22 Oct 2026 17:55:13 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

sloth-tidy — a local file organizer that tidies a messy folder overnight, files it the way you file it (not the way a generic tool guesses), and gets better every time you tell it it's wrong.

It is deliberately not the first "point a local LLM at Downloads" tool. Plenty shipped this month (@tahary's daemon-style SlothTidy, @sufian_khan's Messimo, and more). In every one of them the same failure shows up after a few nights: the model files your invoices the way an average user would, and it commits the same mistake on night 14 that it made on night 1. You unfile it, life moves on, the tool learns nothing.

sloth-tidy is built around three mechanisms that close that loop:

Habit profiling. Before classifying anything, a read-only scanner walks the folders you already organize yourself — ~/Documents, whatever you keep tidy — and learns your taxonomy, your naming style, and your filename habits. If your folder is called Work & Career, the model is never even offered the choice Work; the allowed enum in the prompt is built from your real folder names.
Undo-as-feedback. sloth-tidy undo doesn't just reverse a run — every reversal is recorded as a correction, and the next run's classify prompt carries your recent corrections: "the user rejected this filing; do not repeat it." Fix it once, never again.
Two-model consensus. Any file the primary model (gemma3:4b) tags below 0.7 confidence also gets a second opinion (qwen2.5:3b). Agree → file it with the weaker vote's confidence. Disagree → one richer reconsider pass with both opinions in context; still shaky → honest Unsorted.

And because this thing is going to move files while you sleep, safety isn't an afterthought — it's the architecture:

Dry-run default. Nothing moves unless you explicitly pass --apply. The preview is computed by the exact same destination math as apply, so the table you approve is what happens.
Move-only. shutil.move is the only filesystem verb in the codebase. No delete, no overwrite, anywhere.
Journal-first. Every move is recorded pending in an SQLite journal before the move and marked done (with the final destination) after. A crash can only leave a pending row — undo refuses those.
Never overwrites. Collisions get -2, -3, … suffixes — during apply, and during undo.
Undo forever. sloth-tidy undo reverses the last run (or any run by ID) newest-first. A vanished destination is logged honestly as skipped_missing; a re-filled source spot gets the file restored beside it, never through it.

Code

Repo: https://github.com/Abhinav412/sloth-tidy

The fastest repro is three commands — a generated messy folder, previewed, then applied:

python tests/make_samples.py demo/messy-inbox   # 16 messy files incl. a dupe pair
sloth-tidy run --config demo/config.yaml        # dry-run plan table — nothing moved
sloth-tidy run --config demo/config.yaml --apply

…and sloth-tidy digest in the morning, sloth-tidy undo when the weekend-you disagrees with the overnight-you (that disagreement becomes the training data the next run consumes).

The part I'm most convinced by is the journal contract. A planned move is two-phase:

# mover.py — journal-first move: pending BEFORE the filesystem feels it
for fi, decision, _meta in plan.decisions:
    planned = target_for(fi, decision, settings, now=now)
    move_id = journal.record_pending(run_id, fi, decision, planned)
    # ... then the move, then mark_done(move_id, final_dst)

Undo lives on the other side of the same coin, and writes the correction
memory the next run consumes:

# mover.py — undo_run: never combine a restoration and a lesson
for m in moves:                                   # newest-first
    if not m.dst.exists():
        journal.mark_skipped_missing(m.id)        # honest, not a crash
        continue
    restored = unique_destination(m.src)          # src free -> src, occupied -> src-2
    shutil.move(str(m.dst), str(restored))
    journal.mark_undone(m.id)
    journal.record_correction(run_id, restored, m.dst, m.category)

The category enum is enforced at inference time with Ollama's format=<json schema> — schema-constrained decoding, not "please return JSON" hoping:

# classify.py — the model physically cannot invent a category
category_schema = properties.get("category")
if category_schema is not None and categories:
    category_schema["enum"] = list(categories)

Safety has its own test file (tests/test_safety.py): never-overwrite, journal
round-trip, undo reversibility, corrections dedupe, consensus ladders.

How I Built It

Everything runs on open-weight models through Ollama,
on your laptop, with design choices tuned for small open-weight models:

Schema-constrained prompts. The pydantic Decision model (flat, 4 fields — category, new_name, summary, confidence) is compiled to a JSON schema with your category enum injected, passed as Ollama's format. Temperature 0. Invalid or off-enum output gets exactly one corrective retry that carries the real validation error, then a deterministic Unsorted fallback. Hard cap.
First profile, then classify. sloth-tidy profile walks your organized directories once, caches a HabitProfile (categories, naming examples, style rules), and it merges into the prompt ahead of any manual config.yaml list.
Consensus ladder, bounded. File → model A. If A is confident, no second call — obvious files shouldn't pay for two votes. Anywhere else, model B votes; agreement takes the minimum confidence (honest number), disagreement triggers one reconsider pass with both opinions in context, and a persistent disagreement lands in Unsorted/ — original filename untouched, because if we don't trust the category we shouldn't trust the invented name either.
Digest from journal, not from disk. The 2-line morning summary is built from what the journal recorded, so what you read is exactly what happened — even if users touched files since.
No surprises in memory: corrections dedupe by (src, dst, wrong_category), so repetitive undo cycles never balloon the prompt.

Why Does Open Innovation Matter?

For this project, open is the whole trust story:

Nothing leaves the laptop. File contents — invoices, contracts, personal scans — are snippets sent to a localhost daemon. A cloud API means shipping your private papers to someone else's quota-policy. Here there is no network path at all in the classification loop.
It costs nothing to run forever. An overnight organizer only creates change if you leave it running — with 4B/3B open models on Ollama, that's electricity, not a subscription.
The habit profile is the product, and it's only possible locally. A closed service can't build "your" taxonomy, because they'd have to walk your folders. Mine reads them once, per cache day, and keeps the walk fully offline.
Swappable models. The config lists models, not an account: put any two local models in models: — tonight's consensus pair changes with two lines.

My Agent Session

The full three-day build — design decisions, the journal-first safety contract,
the consensus ladder, every test fix — is saved and embeddable:

sloth-tidy: building a habit-mirroring local file organizer (3-day build)

You

Build the sloth-tidy project per ARCHITECTURE.md: a local Ollama-powered overnight file organizer with habit-mirroring, corrections memory, and two-model consensus for the Hacktoberfest Week 3 'Slow and Steady' challenge (due Oct 25).

Agent

Research note: the Week 3 field already has 15+ entries including a same-named SlothTidy daemon. The open lane is habit-mirroring: profile what folders/naming the user already maintains, feed that into the classify prompt, and make every wrong filing a correction the model never repeats.

▸ write models.py pydantic contracts: Decision (flat 4 fields = the Ollama JSON schema), FileIn...

Input

pydantic contracts: Decision (flat 4 fields = the Ollama JSON schema), FileInfo, HabitProfile, Correction

Output

created; validators inject allowed_categories via context

Agent

▸ write profiler.py read-only walk of the user's organized folders -> categories, naming examples...

Input

read-only walk of the user's organized folders -> categories, naming examples, style summary, JSON cache

Output

created; noise/Windows filters included

▸ write scanner.py top-level scan with skip rules + mtime-ordered SHA-256 dupe pairing

Input

top-level scan with skip rules + mtime-ordered SHA-256 dupe pairing

Output

created; 1 partial download and 2-dupe pair detected on demo folder

▸ write classify.py schema-constrained Ollama call + bounded 1-retry ladder + deterministic Unsor...

Input

schema-constrained Ollama call + bounded 1-retry ladder + deterministic Unsorted fallback

Output

created; category enum injected into Ollama format schema

▸ shell pytest tests/ python -m pytest tests/

Input

python -m pytest tests/

Output

42 passed (Day 1 suite green)

You

Agent

Day 2 = the safety layer. Journal-first contract: every planned move is recorded 'pending' in SQLite BEFORE the filesystem sees it, marked 'done' after. Undo only touches 'done' rows, newest-first.

▸ write journal.py runs/moves/corrections tables + WAL, two-phase status marks

Input

runs/moves/corrections tables + WAL, two-phase status marks

Output

created

▸ write mover.py shared target math for preview AND apply, unique_destination -2/-3 suffixes, ...

Input

shared target math for preview AND apply, unique_destination -2/-3 suffixes, apply_plan journal-first, no overwrite ever

Output

created; broken-symlink case handled via lexists

▸ edit classify.py two-model consensus: solo when A confident, B votes below 0.7, disagreement -...

Input

two-model consensus: solo when A confident, B votes below 0.7, disagreement -> one reconsider pass, dead-B degrades to solo-A

Output

edited; consensus_min wired from settings

▸ write digest.py 2-line digest + move table built from journal truth, not from disk

Input

2-line digest + move table built from journal truth, not from disk

Output

created; write_digest lands in dest/digest.md

Agent

▸ shell pytest tests/ python -m pytest tests/

Input

python -m pytest tests/

Output

61 passed, exit 0 — safety suite covers never-overwrite, journal roundtrip, undo reversibility, corrections dedupe, consensus paths

▸ shell CLI live loop run (dry) -> run --apply -> undo -> digest on demo folder

Input

run (dry) -> run --apply -> undo -> digest on demo folder

Output

14 files journaled run 1; undo restored 14/14 byte-identical; 16 corrections written; digest reprinted

Agent

Found and fixed during the loop: dead model B initially punished the file with a fabricated disagreement — now B's death degrades to solo-with-A. Undo consolidated into mover.undo_run so CLI and tests share one code path.

You

go ahead with day 3

Agent

Day 3: README (lead with habit-mirroring + corrections memory, not file-tidying), MIT license, .gitignore, demo walkthrough, and the #hf26challenge submission draft following the challenge template.

▸ write README.md invariant table (dry-run default, move-only, journal-first, never-overwrite, ...

Input

invariant table (dry-run default, move-only, journal-first, never-overwrite, undo forever), scheduling via schtasks + cron, honest limitations

Output

created; config defaults verified against code

▸ gateway create_article DEV draft staged (not published), tags devchallenge/hf26challenge/python/ai

Input

DEV draft staged (not published), tags devchallenge/hf26challenge/python/ai

Output

draft id 4898757 staged; unterminated HTML comment fixed via update_article

You

repo url set, publish the draft along with saving the agent session

Agent

Submitting this session to DEV, embedding it into the draft's 'My Agent Session' section, and publishing on the user's explicit go-ahead.

The Lazy Payoff

The stall: my Downloads folder is the eternal triage list — every few days, ten
minutes of poking, re-filing and "where does this even belong". The payoff:

~16 files nightly, and after two undo cycles the same mistake never comes back
One command, scheduled, no UI, no paid API
The real payoff is qualitative: it's the first organizer I trust unattended, precisely because a bad filing costs one undo command and zero future nights — the undo handles it, the memory remembers it.

Prize Categories

Best Use of Gemma (featured, $200) — gemma3:4b is the primary classifier in the consensus pair: schema-constrained by habit profile, corrected by user memory, second-opinioned by a smaller model.