The context your AI agents have been missing.

A new ⚙️ Settings page lets you manage Celeborn Code's skills, review the safe auto-allow baseline that cuts permission prompts, and arm a guarded Danger Zone for power users — all driven through the audited CLI, never by editing config by hand.

Celeborn Code installs a curated set of Claude Code skills at setup and quietly refreshes them in the background, so your agent's toolkit stays up to date without you babysitting it.

The local board and the hosted board now share a single UI package. Every board improvement lands in both places at once, instead of being built twice and drifting apart.

In-progress cards show a context-derived percent-complete bar that fills with a settling, granular sand animation — color-coded green, amber, or red — so a single glance at the board tells you the momentum of every card.

Each card's sand bar very subtly embosses an Alan Watts quote that advances as the work progresses. You won't notice it unless you look closely — which is the point.

Done is now half-width and collapses long cards to a title with a “show more” toggle, giving the columns that actually matter — Doing, To Do, Blocked — room to breathe.

You can now remove a project from your hosted board — handy when the underlying repo is gone and you want a clean dashboard.

An opt-in safe permission baseline pre-approves read-only commands and in-tree file edits, so you stop clicking Allow for ls, grep, git status, and routine writes. Destructive and outward-facing actions still ask, every time.

The local board now supervises itself and comes back within seconds if it ever drops, instead of going dark in the middle of a session.

Celeborn Code can answer structural questions about your entire codebase — call chains, routes, impact, dead code — through a pre-approved, never-prompting query surface. No stream of grep and Bash approvals breaking your flow, and your code never leaves your machine.

The hosted board syncs in real time: edits made on the web reconcile back into your repo's task list, and changes appear without a manual refresh.

A new GitHub App posts a non-blocking “memory drift” check on pull requests and captures PR and issue threads into your project journal. Capture is free; pulling threads into local memory is a Pro feature. It never writes your private memory back out to GitHub.

Each card now carries a logical “clean place to stop.” An agent always knows when it's safe to clear context without losing the thread — and the board fills in a sensible default so no card is ever stop-less.

Tasks are now labeled per project (like CELE-t117), so a fleet of agents working across many repos never confuses one board's cards for another's.

Celeborn Code coaches your agent on its own workflow — recommending tests, review gates, security review, and verification at the right moment — and works across Claude Code, Grok, and Codex.

celeborn run gives autonomous multi-agent swarms a live heartbeat and a shared blackboard, so one worker's discovery instantly reaches all the others.

Every file touch and claim is now labeled with which agent and model made it, and the board shows a running total of the tokens and dollars Celeborn Code has saved you.

An install-integrity self-check, a published public contract for the file and CLI formats, and a guiding principle that the server never trusts the client — so a tampered local copy can't grant itself a paid tier or read anyone else's data.

See live status across every repo at once — who's working, who's stuck, and who's idle — from a single view.

celeborn doctor now flags when your saved notes contradict the repo: a deleted file, a swapped dependency, a renamed module. The trust feature that lets you actually rely on the memory.

celeborn flex prints a shareable brag card — tokens never re-loaded, restarts avoided, and dollars saved — straight from your own usage.

Panic-save snapshots your project memory the instant the context window is about to be compacted, with a one-command restore. A /clear or a full restart never loses your place.

celeborn why “<topic>” and celeborn blame <file> surface the decision, its date, and the reasoning from weeks ago — your project remembers not just what changed, but why.

Register who's editing which file before a shared edit, so parallel agents see each other coming and don't clobber one another's work.

celeborn init now reads your repo on first run — README, build manifest, git history, top languages — to pre-seed its memory in under a minute.

Connect a Jira project from the board with a guided token setup, and push your Celeborn Code task board to it. Celeborn Code stays the live source of truth; Jira is downstream reporting.

celeborn standup and celeborn changelog generate a mechanical, no-model digest of what shipped — pulled from done cards, git commits, and journal entries.

Paste a card's marker into any agent and it claims the work automatically — To Do becomes Doing, the owner is set. A per-agent outbox queues work for a specific model.

celeborn plan organizes a body of work into phases with seeded boards, so a long effort has structure instead of a flat pile of cards.

Celeborn Code's task board ships — a local viewer over a markdown source of truth, with drag-and-drop, keyboard shortcuts, fluid animations, and live updates.

The task schema and the celeborn tasks CLI (add, move, edit, show) land. Markdown is the source of truth; the JSON projection is what the board renders.