Every project.
One thread.
Interlace is a cross-project status layer: a deterministic index of what's pending and what got done across all your repos. Turn “wait, what was I doing?” into “right — next up.”
$ lace status ACTIVE PROJECTS scanned 14s ago ● tidepool ▲ 3 pending last touch: 2h ago └─ next: fix websocket reconnect loop src/ws.ts:142 ● papertrail ▲ 5 pending last touch: yesterday └─ next: [ ] ship v0.4 export to CSV ROADMAP.md:18 ● moss-ui ▲ 1 blocked last touch: 3d ago └─ next: review PR #42 “dark mode tokens” github ● driftwood ✓ clean last touch: 6d ago
Why
Context switching shouldn't cost you your context.
Interlace was born from a simple frustration: working on several projects at once means constantly losing your place. You spend a focused weekend on one repo, get pulled into another for a week, and when you come back the thread is gone. What was half-done? What did you already ship? What was the very next thing?
The goal is to multitask between projects and always know where you left off, what you did, and what you need next.
The answers already exist — scattered across git history, TODO comments,
markdown checklists, and GitHub issues. Interlace collects them into one
Postgres-backed index and ranks them deterministically. No LLMs in the
collection loop, no guessing — just an honest, reproducible answer to
“where am I across everything?”
Where did I leave off?
Every project shows its last touch and the exact file and line where work stopped.
What did I get done?
Completed checkboxes, closed issues, and merged work are indexed — your progress is visible, not just your backlog.
What do I need next?
Pending items are ranked by priority across all repos, so the next action is always at the top.
How it works
Collect. Index. Rank.
A boring-on-purpose pipeline: deterministic collectors feed a content-addressed Postgres index, and a ranking pass surfaces what matters now.
Read the signals you already leave
Collectors sweep git state, code comments (TODO, FIXME, HACK), markdown checkboxes, and GitHub issues & PRs across every registered project.
Content-addressed, idempotent
Items land in a Postgres-backed index keyed by content, so edits don't churn results and re-scans are cheap. Done items auto-complete on ingest.
Deterministic priority
A ranking pass orders pending work across all repos — same input, same output, every time. No LLMs in the loop.
The CLI
Meet lace.
One short command between you and your whole workload. Here's a day in the life, with a few example projects.
$ lace project add
Register the projects you juggle. Local path is all that's required; wire up GitHub when you want issues and PRs in the mix.
$ lace project add tidepool --path ~/dev/tidepool --github mariner/tidepool ✓ registered tidepool (git + comments + markdown + github) $ lace project add papertrail --path ~/dev/papertrail ✓ registered papertrail (git + comments + markdown) $ lace project list tidepool ~/dev/tidepool github: mariner/tidepool papertrail ~/dev/papertrail moss-ui ~/dev/moss-ui github: mariner/moss-ui driftwood ~/dev/driftwood
$ lace project-status
Zoom into one project before you dive back in: what you did last, and what's queued up — ranked.
$ lace project-status papertrail # or: lace papertrail s papertrail — ~/dev/papertrail — scanned 31s ago RECENTLY DONE ✓ [x] wire up receipt OCR pipeline ROADMAP.md:14 · 2d ago ✓ resolve FIXME: date parsing off-by-one src/parse.ts:88 · 2d ago PENDING (ranked) 1. [ ] ship v0.4 export to CSV ROADMAP.md:18 2. TODO: handle multi-currency receipts src/ledger.ts:203 3. [ ] write migration guide for v0.4 docs/UPGRADING.md:5
$ lace close
Finished something? Close it from wherever you are. Interlace checks the box in the file and re-scans.
$ lace close papertrail ROADMAP.md:18 ✓ closed “ship v0.4 export to CSV” — checkbox marked done, re-scanned $ lace scan papertrail ✓ papertrail — 2 pending · 14 done · 0.4s
$ lace daemon
Or let it run in the background — watching files and polling GitHub so lace status is always fresh.
$ lace daemon ● watching 4 projects — fs events + github polling 01:12:04 tidepool src/ws.ts changed → re-scan (0.2s) 01:14:31 moss-ui PR #42 review requested → indexed 01:17:56 driftwood clean, nothing new
Under the hood
Deliberately deterministic.
Built to be trusted: the same repos in, the same status out.
Four collectors, one index
Git state, TODO/FIXME/HACK comments, markdown checkboxes, and GitHub issues & PRs — everything lands in a single Postgres-backed index.
Content-addressed items
Items are keyed by content, not position — editing surrounding code doesn't churn the index or reset your ranking.
No LLMs in the loop
Collection and ranking are pure, deterministic code. Your status is reproducible and auditable — never hallucinated.
Daemon mode
File watching plus GitHub polling keep the index warm, so lace status answers instantly whenever you context-switch.
Install
Up and running in one clone.
Node.js ≥ 22pnpm 10ripgrep(rg) for the comment collector- A
Postgresdatabase for the index
$ git clone https://github.com/maggit/interlace.git $ cd interlace $ pnpm install && pnpm build $ pnpm --filter @interlace/cli link --global # point it at your database and go $ lace db migrate $ lace config ✓ mode: local · db: postgres://localhost/lace · collectors: 4
Pick up every thread,
exactly where you left it.
Free, open source, and yours to hack on.