project-sentinel
Health Gecti
- License — License: MIT
- Description — Repository has a description
- Active repo — Last push 0 days ago
- Community trust — 59 GitHub stars
Code Basarisiz
- exec() — Shell command execution in plugins/project-sentinel/hooks/app/commands.ts
Permissions Gecti
- Permissions — No dangerous permissions requested
Bu listing icin henuz AI raporu yok.
Mission control for long Claude Code runs: context and run progress at a glance, Autopilot handoffs, guardrails and a calm activity view, in the terminal and Claude Desktop.
Project Sentinel
Mission control for long Claude Code runs: context, run progress and the prompt cache at a
glance, Autopilot handoffs before the context fills up, guardrails, and a calm view of what Claude
did. For the terminal CLI and for local sessions in Claude Desktop's Code tab.
Project Sentinel was called Control Room until 1.4.0; its panel still is, and /cr still
opens it. An existing install moves over by itself (see Coming from Control Room).
One plugin gives you:
- a calm status bar above the prompt, a mission HUD: what the run is doing or waiting for,
in words, and only what needs a look; below it the run's instruments (work, context, the prompt
cache, the plan's five-hour usage), each its own shape; above it, while subagents run, one line per
agent - the Control Room panel, docked beside the conversation
- Autopilot (Context Autopilot): Claude writes handoff notes, the context is cleared, and Claude
carries on in a fresh one, before this one fills up; then Project Sentinel checks what the handoff
left and what the fresh context picked up - Cache Guardian: the prompt cache in view, why each rebuild happened and how to avoid the
next, model switches confirmed before they throw a large cache away, and Keep warm, which
holds the cache while you are away - run progress that survives those handoffs, with evidence for each verified milestone (it
says when a later change made a verification stale), and an Activity view that leads with what
needs a look, with its own views: Summary, Operations, Agents and Tool calls - Operations, the run over time: work you queue for Claude for later, decisions Claude leaves
for you instead of stopping, watchers that park the run until a result is due and then wake
it, a Cold Resume Guard that asks before a large conversation whose cache has lapsed is
re-read, the agents actually running, and an optional run budget - answer styles: brief, Simplified Technical English, mission-control status calls, or a quest
log with XP for verified progress - policies for effort, finishing the job, subagents and their models, machine load and risky actions,
with profiles that set everything at once. A fresh install starts opinionated (Autopilot at 70%,
Frontier Max at Extra High, permissions left to Claude Code) and says so once; an existing install
keeps what it had. The main conversation's model is never switched - Kit, if you like: a small Claude-orange creature above the status bar that shows what Claude
is doing, and answers a click
Status: 1.8.0. Project Sentinel is built on Claude Code's function-hooks plugin API ("mods"),
which is still early access and may change between Claude Code releases. It is verified on
Claude Code 2.1.289 (the minimum), 2.1.293, 2.1.295, 2.1.296 and 2.1.325 on
Windows 11, and in CI on Linux and macOS. See Compatibility.
Contents
- Screenshots
- Features
- Requirements
- Install
- Using Project Sentinel
- Profiles
- How the systems interact
- Security and privacy
- Compatibility
- Limitations
- Development
- License
Further reading: Configuration ·
Troubleshooting · Design ·
Architecture · Security · Changelog ·
Contributing
Screenshots
In the terminal
![]() |
![]() |
| Overview: the run, then its three lifecycles (work, context and the prompt cache), each with how it starts over. | Activity leads with the run: its milestones, where the turn's time went, and what needs a look, with the line of output that says why. |
![]() |
![]() |
| Context: when Claude hands off, and what happens when it does. | Further down Context, the prompt cache: what it holds and for how long, Keep warm, and each rebuild with what would have avoided it. |
![]() |
![]() ![]() |
| Further down Activity: each check's runs as dots, and every changed file by kind with its diffstat, each opening its diff in place. | Answer styles: how Claude writes to you, each with a line on what it means. The Quest log: XP only for progress Project Sentinel can count, never for lines or tool calls. |
Control Room 1.3.0 in a 150-column Windows console (Claude Code 2.1.293), with the panel
docked beside the conversation (the Answer style and Quest cards are from 1.1.0; they did not
change). The work is a scripted turn played by the development-only
demo driver: Claude Code ran every tool call in it for real (a test that
fails and is fixed, new code with its test, a lint script that does not exist), but no model wrote
the words, and the token counts are scripted, a model switch halfway through included. Claude
Code reports no cost for them, so the cost reads $0.00 (with a + after a cleared session whose
cost was not reported).
In Claude Desktop
![]() |
![]() |
![]() |
| Context, mid-run: one handoff behind it, $115.93 so far. | Behavior: each system on its own card. | Setup: exactly what changed since the profile. |
Control Room 1.0.1 in Claude Desktop's Code tab, from real sessions. On Desktop the controls
are native buttons and popups and the meters are drawn as graphics. What came after (the
two-line status bar, Activity's charts, the answer styles, the Cache card and Kit) has not been
photographed on Desktop yet.
Operations
![]() |
![]() |
| In the terminal: two items queued for the fresh context that watcher W-1 will start when it wakes the run at 17:41. | On Desktop, in the preview: a decision Claude left for you, a button per option and a field for your own words; below it the queue, the watcher form, the agents and a run budget. |


Project Sentinel 1.6.0. The terminal images are captures of Claude Code 2.1.295 in a 150-column
Windows console, set up with /cr commands alone (/cr queue --handoff, /cr watch in 2h … --fresh,/cr budget $30), so no model turn ran. The Desktop images are drawn by
tools/desktop-preview from the trees the plugin draws on thedesktop surface, with the app's own layout rules; its font and colors are close guesses, and
Operations has not been photographed in the app yet.
Features
| System | What it does | Default |
|---|---|---|
| Status bar | A mission HUD above the prompt. The headline says what the run is doing in words, with a mark for its state: working, thinking, running a check, waiting for you, waiting for a result that comes by itself (a background job, a scheduled wake-up), blocked, handing off, done. On its right, only what needs a look (a failing check, issues, a busy machine, agents), then the Control Room button. Below, the instruments, each its own shape: Work (a track of milestones), Context (a bar with Autopilot's handoff notch), Cache (a clock face, only while it matters) and 5H, the plan's five-hour usage as Claude Code reports it (a thin bar, the percentage, the time to the window's reset). A handoff that needs you takes a line of its own above, with its buttons, and while subagents run the agent band sits above everything: a line per agent saying what it is doing, opening Activity → Agents. On Desktop the readings sit in a grid of cells and always keep their places. | On |
| Control Room panel | Six sections: Overview, Context, Behavior, Guardrails, Activity, Setup. A section with several views (Activity) has a second level that never looks like a setting: Activity › Summary over View [ Summary ] Operations Agents (2) Tool calls (a bordered group of buttons on Desktop). Color means something: green verified, amber waiting for you or worth a look, red a failure or a blocker, blue what is current or under way, gray the rest. In the terminal: switches, segmented choices, choices that open in place, and − / + steppers. Every control works with a click or with Tab and Enter, and there are no popups to get stuck in. On Desktop: native buttons and popups, plus graphical meters. |
/cr opens it |
| Autopilot (Context Autopilot) | At a threshold (a % of the window, or tokens), Claude finishes the step it is on. Then it runs a handoff: it records the run's milestones, updates the project's docs, keeps CLAUDE.md for durable instructions only, runs a minimal validation and writes NEXT_SESSION_PROMPT.md in its own words. Project Sentinel then checks that the notes were written for this handoff (wherever they landed: the project root, the working directory or a Desktop worktree, the repository root, or where Claude's editing tool wrote them; proven by Claude's own write, a change since the handoff began, or the time), runs /clear, seeds the fresh context with the run's milestones and objective, and Claude continues on its own. The prompts name the exact path. Every step moves on when its turn starts or ends, never on a timer. A handoff turn that ends while finite background work it started still runs (a render, a test run) waits for that work as Claude Code reports it (20 minutes at most by default), takes its result into the notes, then clears and continues by itself; a server or watcher is never waited for, and work left running is handed to the fresh context, which is told what still runs and since which session. Such work stays a dependency of the run, across any number of handoffs, until Claude Code reports its end, and never holds a later handoff. A fresh context that starts close to the threshold gets room to work before it may hand off again. Each context is measured on its own: a new context's size is unknown until Claude Code reports it, and the old context's figure never carries over. After three handoffs into fresh contexts within 30 minutes the next one, or a fresh context at its handoff point within two turns without growing, is refused (Handoff loop prevented: Recheck, Continue here, Start fresh, Pause Autopilot). A window that shrinks under a model switch (a 1M model reported as 200k) while the context already holds more than the new handoff point holds the handoff (Model window changed unexpectedly) until you take Claude Code's limit, switch back, start fresh or pause Autopilot; Project Sentinel never forces a window Claude Code does not report. Compaction is a choice, or the fallback when clearing is refused (in Desktop and other SDK sessions it runs as /compact). A reload of the plugin mid-handoff carries the handoff on; it never starts a second one. A reload during Project Sentinel's own /clear lets the next load adopt the run and give the fresh context its continuation once. |
On, at 70% (Classic: Off) |
| Handoff Supervisor | Looks at a handoff under way every 30 seconds, with no model call and nothing added to the transcript: how long its step has stood and what holds it (finite work worth waiting for, work that outlasted its wait, a server beside it, a question open to you, a step whose event never came), the notes' state, the wait's deadline and what it does next. It shows in Context and on the line above the status bar with the ways out: Hand off now (leave the work running for the fresh context), Stop & hand off, Keep waiting, Call off; the same as /cr handoff now|stop|wait|cancel, and typing "handoff now" or "don't wait for the server" works too. Only a task nothing recognises is asked about, once, by a small isolated classifier (its command and description only). |
With Autopilot |
| Handoff Health and Continuity | After each handoff, Context → Last handoff shows what it left for the fresh context (run state saved, the milestone under way, the notes, docs updated, validation recorded, whether the verified milestones' evidence is current, what it left running) and, once the fresh context's first turn ends, what it picked up (notes read, run state restored, milestone picked up, docs read, work resumed). Counted from tool calls, never from what Claude says. | With Autopilot |
| Run progress | The run's objective and milestones, done of total, counted from Claude's own task list and carried across handoffs, so the work meter keeps climbing while the context meter starts over. A milestone may also be verifying (with its evidence) or blocked (with what it waits for). Where Claude Code offers no task list (its task tools are off by default in 2.1.29x), Project Sentinel gives Claude a small milestones tool to keep one. Open milestones of an earlier context are carried until a later list names them (a reworded title is matched), Claude marks them dropped, or new work begins. |
On |
| Milestone evidence | When a milestone is completed, what it stood on is kept: the checks green during its work, the files its work changed (and outputs Claude names) with Git's blob id of each, and HEAD. Never the whole repository. Later, a changed file makes that verification stale (never "wrong"), with what changed and which checks to rerun, in Run progress, Attention, Last handoff and Ready to resume; Claude is told at a handoff and in the fresh context. A later milestone changing the same file is quiet while under way and re-verifies it when its checks pass; a change made outside Claude's tools clears once the checks pass again, or when you accept it (/cr evidence accept). |
On |
| Cache Guardian | The main conversation's prompt cache, from the token counts Claude Code reports for each request: how much is cached, how long it stays warm (the cache's lifetime is learned), the share read from the cache, and why each rebuild happened (a model or effort switch, changed policies, a new tool, compaction, idling past the lifetime), with what would avoid the next. Project Sentinel never switches the main conversation's model: a prompt cache belongs to one model. A switch you make that would re-send 100k+ warm tokens is confirmed first: a /model or picker switch in Claude Code's own dialog; a switch from Desktop's model picker, Remote Control or an IDE, which comes with no such dialog, at your next message (Model switch: Switch back, which runs Claude Code's /model and then sends the message; Send anyway; Start fresh, when the resume state is healthy; Cancel, which puts the message back in the prompt box). An effort change is seen at the request it goes with (Claude Code reports none before): Claude Code documents that Fable 5.1 and later, Opus 5.5, Sonnet 5.5 and Haiku 5.5 keep their cache across effort levels, other models likely rebuild, and a rebuild seen on this machine is learned; a large rebuild nobody confirmed is said in a toast. Thinking settings are traced only, never guessed. While the cache is warm, setting changes reach Claude as notes instead of rewriting the cached system prompt. |
On |
| Keep warm | Refreshes the prompt cache shortly before it lapses while you are away, by re-sending the last request once (the transcript never sees it), for up to an idle limit you set. Each refresh costs tokens, mostly cheap cache reads. The refreshes are then checked against the conversation's own next request: VERIFIED when it read the cache after an expiry they replaced, FAILED (and Keep warm pauses) when it rebuilt with nothing changed. A refresh Claude Code had to retry through a network blip, answered only after the expiry, is not counted against it. /cr cache lists them. Two clocks, never mixed: the cache's lifetime, renewed by each request or refresh that reads it, and the idle limit, counted from the end of the last turn, which a refresh never resets. While Claude works, Context → Cache reads Ready (the countdown has not started); while you are idle, how long you have been idle, how much Keep warm has left, when it started and stops, the next refresh and when the cache expires without one, the cache's lifetime and where it came from, and the refreshes so far. On a 5-minute cache the limit in force is 45 minutes at most (past that, refreshing costs more than rebuilding), and a watcher can hold the cache past the limit until it wakes; either is shown beside the limit you asked for, with why. Readings only, never estimates. |
Off |
| Mission Queue | Work you give Claude for later without interrupting it: from Activity → Operations (Add work for later, with when it goes) or /cr queue <text>. Each item goes only at a boundary: the next safe one (the milestone under way completes or the turn ends), after this turn, after the current milestone, or into the next fresh context. Never into a turn's reasoning: an item due mid-turn goes with the next batch of tool results, otherwise as a prompt of its own when the turn ends. Edit, reorder, deliver now or delete; kept with the run across /clear, handoffs, reloads and resumed sessions, delivered once. |
On |
| Decision Inbox | Claude is offered one tool, decision_request, for a choice that is yours and need not stop the work (which approach, whether to delete generated files, whether to publish once CI passes). It waits in Activity → Operations → Needs review with its options and a field for your own words; /cr decisions lists them, /cr decide D-2 asks in Claude Code's own dialog. The answer reaches Claude with its next tool results while it works, as a prompt of its own when the run waits on it, else with your next message. Claude Code's permission prompts and confirmations are never deferred here. |
On |
| Watchers | Park the run until a time, then wake Claude to check what it was waiting for: Operations → Watchers or /cr watch in 2h S-002 result (at 14:00, tomorrow at 9am; an ambiguous at 2:30 is asked, never guessed). Keep warm holds the conversation's cache to the wake, Fresh spends nothing and wakes in a fresh context from the handoff notes, Smart chooses and says why. A watcher never clears a run that moved since it was armed: it says Watcher due and offers Check now, Reschedule or Dismiss. A fresh wake needs healthy resume state. Watchers run while Claude Code runs (no daemon is installed); one due while it was closed waits for you when the session is open again. The Scout suggests one when Claude says it will check back at a time (Off, Suggest, or Arm explicit waits). |
On (Scout: Suggest) |
| Cold Resume Guard | Before a message is sent into a large context (100k tokens by default) whose prompt cache has surely lapsed, Claude Code's own dialog asks first: Continue full session, Start fresh from resume state (only when Context → Ready to resume is ready), Compact first (it reads the context once more, then sends the message into the compacted one), or Cancel (the message comes back to the prompt box). It says why the cache lapsed and how many tokens would be reprocessed; a price only as Claude Code's own estimate for the model, as a floor (at least ~$0.46). It uses the cache lifetime Claude Code is configured for, and counts Claude Code's own requests while you are away (its away summary) as keeping the cache warm. The message goes once: the copy Claude Code puts back in the prompt box is cleared. Only messages a person sends are guarded, never a task notification, a scheduled trigger or a peer's message; the debug log says for every message why it did or did not ask. A lapsed cache on a model you switched to is asked about once, as a cold resume that says the model changed too. | On |
| Agents | Activity → Agents, while agents run or ran lately: each agent under its parent (a workflow's under its run), with its type, model and effort, status, time, what it is doing now (its latest call), its calls, its own plan as a track when it keeps one (never a made-up percent), its own compactions (how many, when, the size left), and its result or failure. An agent shows from its spawn, before Claude Code lists it; one whose spawn was not seen (begun before a reload) from Claude Code's SubagentStart, and an end not otherwise seen from its SubagentStop; workflow agents, which Claude Code never lists, show from their own loop. Stop and Message are Claude Code's own TaskStop and SendMessage, offered only for agents that take them; Resume sends your message to a subagent this session saw finish, and Claude Code resumes it from its transcript (never a workflow's agent, a fork or a teammate). Each subagent has its own context and compacts it itself; Claude Code reports no context usage per agent, so none is shown. No subagents in this context is said only when nothing at all was seen. The agent band above the status bar shows the same at a glance, each agent with its model. |
Always |
| Plan usage (5H) | The plan's five-hour window as Claude Code reports it ($.session.usage().rateLimits): 5H 63% · 2h14m on the status bar, amber from 80%, limit in red at 100% or when a request is refused on the rate limit, reset · new window once the window resets until a response reads the new one, — before the first reading; nothing on an account with no five-hour window. Context → Run spells out the five-hour and seven-day windows. Never estimated. |
On |
| Run Budget | Optional limits on the run's cost (as Claude Code reports it), wall-clock time and handoffs. Said once at 80%; at a limit: notify only, ask before Project Sentinel starts more work by itself, or have Claude finish the milestone and pause. Nothing stops a tool call or a turn under way. | Off |
| Activity | The run's milestones, then where this turn's time went (a strip colored by reading, editing, running and checking) and a few counted lines. What needs a look comes next: failures nothing has fixed (with the line of output that says why), refusals, slow calls. Then the checks (tests, build, type-check, lint), each run a dot, and every changed file grouped as code, tests, docs and config, each with its diffstat and its diff. Every tool call is the secondary view. | /cr, Activity |
| Session chain | Follows a run across context resets: sessions, times, peak context, cost per session as Claude Code reports it, total cost, handoffs. | On |
| Frontier Max | Senior-engineer standards in the system prompt (investigate, finish, verify, report honestly), plus the reasoning effort you choose (Extra High by default, Maximum one pick away) on each request where the model has an effort setting. It never changes the model, and no longer turns the lazy-exit guard on by itself. Models without an effort setting get none, never a fake one. It is in the first request of a session, after a /clear or a compaction, and when turned on mid-session (a note while the cached system prompt is held). Behavior → Frontier Max says how it reached Claude and at what effort, read from the requests themselves; /cr diagnostics shows it request by request (fingerprints only). |
On, Extra High (Classic: Off) |
| Lazy-exit guard (No-Lazy-Exit Guard) | Continues the turn when Claude stops before the job is done: work handed back to you, "next steps" it could have taken, unverified claims. It leaves genuinely finished work, real blockers, your decisions and optional ideas alone. It has per-turn and per-session caps and stands down during a handoff. | Off |
| Release check | A verification-first policy: test before calling work done, and say plainly what was not checked. | Off |
| Answer styles | How Claude writes its messages to you: Standard; Brief (the answer first); Plain technical (Simplified Technical English, after the writing rules of ASD-STE100); Mission control (GO, NO-GO and HOLD calls, GO only for what was verified); Quest log. Never code, files or commit messages. A Claude Code output style you chose outranks them. | Standard |
| Quest log | A light game layer for the Quest log style: XP only for outcomes Project Sentinel counts (milestones done, checks turning green, finished plans, verified handoffs), never for lines or tool calls, with levels, achievements and the level in the status bar. Claude is told never to state points itself. | With the style |
| Agent Model Policy | Which model a subagent runs on, by its kind of work: explore / search, research, planning / architecture, implementation, debugging, review / QA, security, general. Each takes the agent's own model (its definition's, or Claude's choice), the session's model, Haiku, Sonnet, Opus, or Fable (once Fable has been seen answering in the session), with overrides per agent type. The kind comes from the agent type, then the words of its description, with no model call. A model Claude names in its Agent call is kept, a fork runs on its parent's, a workflow's agents keep the script's, and a family Claude Code refused this session is not asked for again. Turned on with nothing chosen, it starts from a suggestion: explore Haiku, research Sonnet, planning Sonnet, implementation the session's model, debugging Opus, review Sonnet, security Opus, general the agent's own. Behavior → Models and /cr models. The main conversation's model is never switched (the model router of 1.7 is gone; its subagent choices carry over). |
Off |
| Advisor | Claude Code's own advisor (/advisor): a stronger model Claude consults at key moments. Behavior → Models shows what it is set to (advisorModel, read back from Claude Code's settings: the setting, never what was asked) and how often it was consulted in this context, by the main conversation and by subagents. Choosing one there or with /cr advisor runs Claude Code's own /advisor, which saves it in your user settings. Claude Code does not tell plugins which models this account has, so the documented ones (Fable, Opus, Sonnet) are offered as unconfirmed until /advisor's own reply names them; where Claude Code offers no /advisor, it reads Not available. It is session-wide: subagents inherit it where Claude Code pairs it with their model, and there is no advisor per subagent. Changing it keeps the cached conversation. |
As Claude Code has it |
| Subagents | No limit, up to N at once, ask each time, or off. Live counts are shown. | No limit |
| Focus view | Presentation only. Tool calls become one compact line each, results and inline diffs are hidden, and the spinner reads Working · 27 tools · 6 files changed · tests running. Activity keeps every call and every diff. Claude still reads everything. |
On |
| Machine load (Resource Governor) | Advisory CPU and memory ceilings (Low, Medium, High or Custom), from a lightweight machine-wide sampler. Claude is told about pressure mid-task, extra heavy jobs can be held back, and only Claude-started background jobs can be stopped. It is not an OS quota. | Off |
| Permissions (Permission Policy) | Default, Ask or Deny per category: package installs, network, downloads, project edits, edits outside the project, deleting files, commits, push, force push and resets, deploy and publish, and dangerous commands. Default leaves the action to Claude Code's own permission mode and rules (it is not "allow everything"); Ask always asks you first, in Claude Code's own dialogs, even in a permission mode that would not ask; Deny refuses. It never answers a permission prompt for you, and never loosens a deny, plan mode or your organisation's settings. Each value says what it means: Claude Code decides, or what Project Sentinel adds on top of Claude Code. Use the Guarded set (or the Guarded profile) adds Project Sentinel's own set: installs, downloads, edits outside the project, deletes, pushes and deploys ask; force pushes, resets and dangerous commands are denied. All to Default goes back. | All Default (Guarded: 2 Deny, 6 Ask) |
| Profiles | Normal (the fresh-install defaults), Guarded (Normal with Project Sentinel's Ask/Deny set), Frontier Max, Low Resource, Release / QA, Classic (Normal as it was before 1.7) and your own. Setup shows exactly what changed since you applied one. | Normal |
| Kit (the companion) | A small Claude-orange creature in a lane above the status bar, in the terminal and on Desktop, that shows what Claude is doing: pacing while it thinks, typing while it works, reading in round glasses while it searches, watching a check, a dance with confetti at a green finish, a facepalm at a failure, a question mark when the run needs you, fanning itself on a busy processor, tending a small fire while Keep warm holds the cache (or a watcher holds it to its wake), curled up asleep while a watcher parks the run, dozing as the cache nears its expiry, carrying the notes off at a handoff and walking back in, curled up asleep when nothing happens. What it does comes in short episodes picked at random per mood, never the same twice running, and it walks to where it has not been lately, so it uses the whole status bar. A touch reacts by where it lands: a pat on the head, a boop on the nose, a tail flick, a pet on its body (a purr, a roll for a belly rub, a blush…); a few in a row make it giggle, then dizzy. It never jumps: it walks, turns and sits down. Calm by design; Reduce motion holds it still. | Off |
| Git (terminal) | The branch, how far it is ahead of or behind its upstream, and the uncommitted files, in Overview and /cr status, from one read-only git status after a turn. Desktop's Git strip is the app's own; plugins cannot draw, hide or move it. |
In a repository |
Cost is shown only as Claude Code reports it, and "—" means it was not reported. Progress is
milestones done of the total Claude listed. The cache's expiry, hit ratio and causes are derived
from the token counts Claude Code reports, and the panel says so. Nothing is estimated.
Requirements
- Claude Code 2.1.289 or newer with function-hooks plugins (mods). Check with
claude --version. - The terminal CLI, or Claude Desktop's Code tab for local sessions.
- Nothing else. Project Sentinel has no runtime dependencies and no build step, because Claude
Code loads its TypeScript directly.
Install
Install it (terminal and Desktop)
Add the repository as a marketplace, then install:
claude plugin marketplace add Arjun0014/project-sentinel
claude plugin install project-sentinel@control-room
The marketplace keeps its name, control-room; the plugin in it is project-sentinel. Or do
both from inside a session (Claude Code 2.1.275 or newer):/plugin install project-sentinel --marketplace Arjun0014/project-sentinel.
A local clone works too: claude plugin marketplace add /path/to/project-sentinel. The terminal
reads an installed folder marketplace straight from the folder, so after you pull changes, run/reload-plugins in a session. Desktop's Code tab may load the copy Claude Code made when you
installed, so it needs claude plugin update project-sentinel@control-room after a new version,
then a new session.
Coming from Control Room
Installed as control-room@control-room before 1.4.0? Update the marketplace:
claude plugin marketplace update control-room
The marketplace maps the old name to the new one, so the update moves your install toproject-sentinel@control-room (your enabledPlugins entry included), and the next session
loads Project Sentinel. When it first loads it reads the store it kept as Control Room once (the
one written last, where Claude Code kept more than one) and copies your settings, runs, Quest log
and what it learned about the prompt cache into its own store; the old file is left as it was.
Sessions that were open during the update keep Control Room until they restart; Project Sentinel
stands by in them, so the two never act at once. Two things changed in behaviour: the Allow permission
state is gone (a saved Allow reads as Default: in Bypass permissions mode nothing changes,
otherwise prompts it answered come back unless your Claude Code allow rules cover them), and a
click on Kit no longer opens the panel (the status bar's button does).
Update
Each release raises the version, and Claude Code installs it when you ask:
claude plugin update project-sentinel@control-room
To get releases automatically, open Marketplaces in /plugin, select control-room and
choose Enable auto-update. It is off by default for marketplaces you add yourself.
Try it for one session
claude --plugin-dir /path/to/project-sentinel/plugins/project-sentinel
Nothing is installed. The plugin loads from that folder for that session, and edits to it reload live.
Claude Desktop (Code tab)
Desktop's local sessions run the same Claude Code engine and load the plugins installed above.
To load a working copy without installing it, name the folder in the env block of~/.claude/settings.json. Claude Code reads CLAUDE_CODE_PLUGIN_DIRS there for sessions that
the Desktop app starts:
{
"env": { "CLAUDE_CODE_PLUGIN_DIRS": "/path/to/project-sentinel/plugins/project-sentinel" }
}
Use your platform's path-list separator (; on Windows, : elsewhere) for several folders.
Remote (cloud) sessions have not been tested.
Uninstall
claude plugin uninstall project-sentinel@control-room
Settings and run history live in Claude Code's per-plugin store (see Configuration).
Use /cr reset confirm first if you also want the settings cleared.
Using Project Sentinel
The status bar
A mission HUD above the prompt: what is happening on top, the run's instruments below. Settings
live in the panel.
◎ Linting · step 3 of 4 ▲ RAM 83% ◆ Control Room
WORK ●━●━◎─○ 2/4 CONTEXT ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇█▇▇▇▇▇ 47% · hands off 80% CACHE ● rebuilt 446k 5H ▂▂▂▂▂▂ 63% · 2h14m
| Item | Meaning |
|---|---|
◎ Linting · step 3 of 4 |
The headline: what the run is doing, with a mark for its state. While a turn runs: the milestone under way in Claude's words, else the running call, else Thinking; a check running or a milestone being verified is ◎; a call past 20 seconds adds its time; ◆ Waiting for you to approve: git push while a call set to Ask waits for your answer. Between turns, what the run waits for comes first: ◷ Waiting for the test run (a background job), ◷ Waiting to check back · wakes at 06:12 (a scheduled wake-up), ⊘ Blocked: … (something only you can give), ◆ Waiting for your answer (Claude asked you something). ◆ Needs you · 1 decision (a decision Claude left blocks the run), ◆ Watcher due: S-002 result (a watcher waits for you), ◷ Sleeping until 14:00 · S-002 result (a watcher parks the run, with whether the cache is held warm or the wake is fresh). Otherwise what the last turn did in counted words (✓ Changed 4 files · Ran tests 3×, passing after a fix), ✓ All 6 milestones done, or before the first turn the run's objective (○ Ready without one). A handoff under way reads ↻ Writing the handoff notes; one whose turn ended while background work still runs reads ↻ Handoff written · waiting for background work with the task and that it runs (Render the 16:9 master · running), then Handoff complete · checking the notes and Handoff complete · starting the fresh context. |
▲ RAM 83% |
Chips: only what needs a look, the most pressing first. ✗ Lint failing (a check failing, by name), ▲ 2 issues (calls that need a look), Kept going ×1 (the lazy-exit guard continued the turn), ▲ CPU 91% or ▲ RAM 92% near or over a ceiling (the terminal; Desktop has a Machine cell), 2 agents, ★ Lv 4 with the Quest log style. The orchestration layer's chips are buttons that open Activity → Operations at their own card, the mark in its color: ▲ Review 2 (an amber mark: decisions waiting for you), ◷ Watcher 1h 42m (a watcher armed while the run is not asleep), ● Queued 3 (queued work due when the turn ends), ▲ Cost $25.00 of $30 (the run budget near or at a limit). None shows while there is nothing to say. |
◆ Control Room |
Opens or closes the panel: a filled button, in Claude orange while the panel is open (◆ Open or ◆ Close when the bar is narrow). |
WORK ●━●━◎─○ 2/4 |
The run's milestones, done of total, from Claude's own task list: ● done, ◉ under way, ◎ being verified, ◌ waiting or blocked (amber), ○ to come. It carries across handoffs, so it keeps climbing while Context starts over. |
CONTEXT ▇▇▇▇█▇▇ 47% · hands off 80% |
How much of the context window is in use: a solid bar, green, amber near the handoff point and red past it (with Autopilot off, against 90% of the window), and the handoff point as an orange notch. It starts over after a handoff, and a handoff under way says so beside it (Handoff soon, Writing the handoff, Waiting for background work, Checking the notes, Starting fresh, Resuming, Waiting for you). A new context reads — until Claude Code reports its size (a request made in it answered, or the size a compaction or a resumed session reports): the old context's figure never carries over. After a reload of the plugin, with no context boundary seen, the session's figure is drawn with ~ (~47%): provisional, and never acted on. |
CACHE ● rebuilt 446k |
The prompt cache, only while it can matter: when you are away, a clock face emptying as its lifetime runs out and the time left (◕ 42m left; lapsed? when it may have lapsed), amber near the expiry with no refresh coming; and for a few minutes after a costly rebuild, rebuilt 446k. While Claude works its requests keep the cache warm, so the terminal leaves it out (Desktop keeps its cell: warm · 345k), and it never reads lapsed? during a turn. |
5H ▂▂▂▂▂▂ 63% · 2h14m |
The plan's five-hour window, as Claude Code reports it: a thin bar (blue, amber from 80%), the percentage and the time to the window's reset, redrawn each minute while it counts down. 5H — before the first reading; 5H reset · new window once the reset time passes, until a response reads the new window; 5H limit · 1h30m in red at 100% or when Claude Code ends a request on the rate limit (Rate limited when no window reads full), until a turn is answered again or the window resets. Nothing on an account with no five-hour window (an API key). The run's cost is in Overview, Context → Run, /cr status and the Run Budget. |
WATCHER ◷ 1h 42m |
Only while a watcher parks the run: the time to its wake. On Desktop it takes the Machine cell's place (nothing runs, so the machine is not the story). |
Width decides the detail. The names (WORK, CONTEXT, CACHE) show from 72 columns (5H names itself at every width), docked
beside the panel included; the meter and the track shorten before the least important reading
drops. The empty part of the meter and the HUD's top edge are drawn in the theme's quietest gray,
the same in every terminal.
On Desktop the same readings sit in a row of five cells: Work, Context, Cache, Machine (CPU and
memory as slim level bars with their percentages, amber near a ceiling and red at it) and the
plan's 5-hour usage at the right edge (Plan usage — on an account with no five-hour window), each a quiet caption over its graphic and value, the button native.
The columns are weighted by what they hold (Work and Context wider), and the five always keep
their places, a dim word standing in for one with nothing yet (No milestones yet, —). Width
decides the detail: the labels and what the cache holds in a wide band, CPU · RAM in a narrower
one, the bars alone in a compact one. The graphics (the state's mark, the track, the meter, the
level bars, the clock, Kit) are drawn as images.
(▸) Running tests · step 3 of 10 ✗ Lint failing [ ◆ Control Room ]
Work Context · hands off at 70% Cache Machine 5-hour usage
●━●━◉─○─○─○ 2 of 10 ▬▬▬▬▬▬▬▬▬┃▬▬▬ 24% ◔ warm · 345k CPU ▮ 34% RAM ▮ 85% ▂▂▂ 63% · 2h14m
When a handoff is about to happen, a line above offers Hand off now and Later; if a
handoff ever waits for you, it offers Start fresh. A written handoff waiting for background
work offers Hand off now (the work keeps running for the fresh context), Stop & hand off,
Keep waiting (near the end of its wait, or once it stalled) and Call off; one the Handoff
Supervisor finds stuck says what holds it and offers what fits. A handoff loop Project Sentinel
prevented offers Recheck, Continue here, Start fresh and Pause Autopilot; a window
change it holds offers Use Claude Code's limit, Switch back and Pause Autopilot. The same line asks about a watcher that waits
for you (Check now, Start fresh when that is safe, In 30m, Dismiss), a message the
Cold Resume Guard kept (Put back, Send now, Discard), the run budget holding automation
(Continue anyway, Budget ›), and the Scout's suggestion (Claude seems to be waiting for a
future result. Check the leaderboard again in two hours? Create watcher, Change time,
Ignore). While subagents run, the agent band sits above all of it: a line per agent with its
model (researcher · Sonnet · reading docs · plan 2/4 · 3m; up to three, more are counted by what
they do, 5 agents · 2 reading · 2 editing · 1 checking), each opening Activity → Agents, and gone
when none runs. With the companion on (Setup →
Companion, /cr companion on), Kit lives in a lane above the headline: in the terminal it
stands on the status bar's top edge, on Desktop it is drawn in finer pixels. Give it a click.
Claude Desktop's Git strip is the app's own: plugins can neither draw, hide nor move it, so
Project Sentinel shows no Git UI on Desktop. In the terminal, Overview and /cr status carry the
branch and the uncommitted files.
The Control Room panel
/cr (or /control-room) opens or closes it, and so does the status bar's button. In the
fullscreen terminal from 110 columns it docks beside the conversation; otherwise it opens in a
frame above the prompt. A wide frame (a wide terminal, or a Desktop pane at full size) keeps the
page to 80 columns, centred. Opened by you, it seats at any width. If it opens on its own (Open
at session start), it waits for 144 columns.
Click anything, or move with Tab, choose with Enter, and return to the prompt with Esc.
Choosing a section starts its page at the top, and every page ends with ↑ Sections.
| Section | Answers |
|---|---|
| Overview | How is this run doing? Anything that needs you sits on top (and, once after a fresh install, a short Sentinel is on card). Then the run (its number, the session, its cost and objective; in the terminal, the Git branch) with what is happening now right under it, an Operations card only while something is in it (Review 2 · Watcher · wakes in 1h 42m · Queued 3 · Agents 2 active · Budget), the three lifecycles as cards, Work, Context and Cache, each with how it starts over, and one card per section with its systems, each with its switch and one line of state (Setup's holds the profile). |
| Context | When does Claude hand off, and what does the cache hold? The Autopilot's state, meter and settings; the prompt cache (Cache with Keep warm's clocks, then Cache health with the recent rebuilds); the Cold Resume Guard (its switch, the size it asks above, whether it would ask now and why); Ready to resume (what a fresh context would get: the run, its milestones, what it reads, what it carries, the next action, a milestone whose verification is stale, or why a fresh start is not offered; quiet unless a fresh start is in play); the last handoff (what it left, what the fresh context picked up); then the run (its plan usage, its sessions) and earlier runs. |
| Behavior | How does Claude work? The answer style (with a line written in it), Frontier Max (what it does in plain words, its effort, and whether it reached Claude in this context), the lazy-exit guard, Release check, Models (the main conversation's model, which Project Sentinel never switches; the model-switch guard; the Agent Model Policy with a model per kind of work; the latest agent's model and why; the Advisor) and run progress. Finer settings appear only while a system is on. |
| Guardrails | What may Claude do, and how hard may it push the machine? Permissions (each value with its meaning: Claude Code decides, or what Project Sentinel adds on top; All to Default and Use the Guarded set), subagents, machine load with live meters, and Claude's background jobs. |
| Activity | How far is the run, and what needs a look? Summary: the Quest card with the Quest log style, run progress (objective, milestones, now and next, checks), this turn as a time strip and a few counted lines, Attention, Validation with each check's runs, and the changed files by kind, each with its diffstat and diff. Operations: Needs review, Mission Queue, Watchers and Run budget (see Features), and a line to Agents. Agents (while agents run or ran lately): each agent with its parent, model and effort, status, what it is doing, its own compactions and its result, with Stop, Message and Resume where Claude Code takes them. Tool calls: every call, and Focus view's switches. |
| Setup | Profiles (Normal, Guarded, Frontier Max, Low Resource, Release / QA, Classic, your own; with exactly what changed), display (the status bar, live CPU and memory, notifications, the companion, reduce motion, open at start), and about. |
Commands
Every control is also a command. This is handy over Remote Control, for muscle memory, and on
surfaces without the panel.
| Command | Effect |
|---|---|
/cr |
Open or close Control Room |
/cr status |
Everything at a glance |
/cr help |
Command list |
/cr profile [name] |
List profiles, or switch (normal, guarded, frontier, low-resource, release-qa, classic, or a custom name) |
/cr autopilot on|off|70%|700k |
Turn Autopilot on or off, or set its threshold (% of the window, or tokens with k/m) |
/cr autopilot pause|resume|recheck |
For this session only, the saved settings unchanged: pause Autopilot, resume it, or recheck the context after a handoff loop was prevented |
/cr handoff |
Hand off now: notes and NEXT_SESSION_PROMPT.md, then continue in a fresh context. During a handoff it says what the handoff is doing instead (writing, waiting for named background work, checking the notes, starting fresh) |
/cr handoff now · /cr handoff wait [30m] · /cr handoff stop [id|all] · /cr handoff cancel |
A waiting handoff's ways out: go on now and leave background work running for the fresh context; wait longer; stop the work it waits for, then go on; call it off. Typing "handoff now", "don't wait for the background process", "start the fresh session now", "keep waiting" or "cancel the handoff" while a handoff is under way does the same and never reaches the old context |
/cr fresh |
Start the fresh context of a written handoff: waiting for you, or one no event moves on. It starts from notes written in this context, checked first; a server or watcher still running never holds it (it keeps running for the fresh context); finite work does, and it says so |
/cr fresh now |
The same, past work that still runs: it keeps running, and its result reaches the fresh context |
/cr fresh force |
The same from notes Project Sentinel could not verify, after asking in Claude Code's dialog (Start fresh anyway / Keep this context). Where no one can be asked, nothing is cleared. Typing "start fresh now" during a handoff does the same |
/cr window · /cr window accept|back|pause |
A window change Autopilot holds: what changed; take Claude Code's limit, switch back to the model before (Claude Code's /model), or pause Autopilot for this session |
/cr evidence · /cr evidence check · /cr evidence accept [n|all] |
What each verified milestone stood on; compare with the workspace now; accept a stale one's files as they are |
/cr frontier on|off |
Frontier Max (the guard is its own switch) |
/cr guard on|off · /cr qa on|off · /cr focus on|off |
Lazy-exit guard, Release check, Focus view |
/cr style standard|brief|ste|mission|quest |
How Claude writes to you (no argument lists them) |
/cr resources off|low|medium|high|<cpu>/<ram> |
Machine load level, or custom ceilings such as 60/80 |
/cr agents |
What is running now (Activity → Agents) |
/cr agents unlimited|off|ask|<n> |
What Claude may start: subagents |
/cr queue <text> |
Work for later, at the next safe boundary; --turn, --milestone or --handoff first chooses another. Typed while Claude works, it runs when the turn ends and never enters it |
/cr queue · /cr queue list · /cr queue now|cancel <id> |
Open the queue to type in · list it · deliver one now or delete it |
/cr watch in 2h <what> · /cr watch at 14:00 <what> |
Park the run until then and wake Claude to check (--warm or --fresh; Smart by default). An ambiguous time is asked |
/cr watchers · /cr watch now|pause|resume|cancel <id> |
The watchers, and each one's controls |
/cr decisions · /cr decide <id> [answer] |
What Claude left for you to decide; answer one (in Claude Code's dialog when no answer is typed; an option's number or words pick it) |
/cr budget [$30] [6h] [handoffs 5] [notify|ask|finish] · /cr budget off|continue |
The run budget: set, show, remove, or let the run go on past a limit |
/cr resume |
What a fresh context would get now, and whether a fresh start is offered |
/cr models |
The main conversation's model (never switched), the model-switch guard, and the Agent Model Policy |
/cr models on|off · /cr models <kind> <model> · /cr models type <agent-type> <model>|clear |
The Agent Model Policy: on or off (on with nothing chosen starts from the suggestion); a model for a kind of work (explore, research, planning, implementation, debugging, review, security, general; agent, session, haiku, sonnet, opus or fable); or one for an agent type |
/cr advisor [model|off] |
Claude Code's advisor: what it is set to and whether it was consulted; with a model or off, set through Claude Code's own /advisor and read back |
/cr router |
Says why the model router was removed (see /cr models) |
/cr cache |
The prompt cache in words: its state and lifetime, what it holds, Keep warm, and the recent rebuilds with what would have avoided them |
/cr cache keep on|off · /cr cache idle 2h |
Keep warm, and how long it holds the cache while you are idle (45m, 2h) |
/cr cache guard on|off · /cr cache stable on|off |
Ask before a model switch; Keep policies stable |
/cr diagnostics |
Evidence that the settings reached Claude: each request of this context (the policy section's fingerprint, whether Frontier Max was in it and how it travelled, model and effort), the notes delivered, Keep warm's refreshes and their checks. Fingerprints and counts only, never prompt text |
/cr hud band|status|both|off |
Where the status bar draws: above the prompt, in Claude Code's status line, both, or neither |
/cr companion on|off · /cr motion on|off |
Kit, the companion; animation (off is Reduce motion) |
/cr reset confirm |
All settings back to Normal, the fresh-install defaults (custom profiles are kept) |
/cr is registered only if no other command already uses the name. /control-room always works.
Profiles
| Profile | What it sets |
|---|---|
| Normal | The fresh-install defaults: Autopilot on, handing off at 70% into a fresh context that carries on by itself (compacting if the clear fails); Frontier Max at Extra High effort; the Decision Inbox, Watchers and run milestones on; Focus view's quieter transcript; every permission category Default, so Claude Code's own permission mode and rules decide. The lazy-exit guard and the Agent Model Policy are off. |
| Guarded | Normal, with Project Sentinel's own Ask/Deny set on top of Claude Code's permissions (the built-in set of 1.7 and earlier): installs, downloads, edits outside the project, deletes, pushes and deploys ask; force pushes, resets and dangerous commands are denied (6 Ask, 2 Deny). |
| Frontier Max | Frontier Max at maximum effort, guard on (standard), Autopilot at 70%, machine load Medium, and the Guarded permission set. |
| Low Resource | As Classic, with machine load Low (CPU 50%, memory 75%, hold all heavy jobs), at most 1 subagent and the Guarded permission set. |
| Release / QA | As Classic, with Release check on, a strict guard (3 continuations per turn), Autopilot at 70%, at most 2 subagents, inline diffs shown, machine load Medium, and the Guarded permission set with commits set to Ask too. |
| Classic | Normal as it was before 1.7: Autopilot and Frontier Max off (its effort Maximum when turned on), everything else as Normal. |
A profile sets everything at once. Change anything afterwards and the profile readsNormal · edited, and Setup lists each change (Machine load Off › Medium). Save any setup as
a profile of your own, or go back to the profile in one click.
New installs and updates. Only a fresh install gets the opinionated defaults (and one short
Sentinel is on card, until Got it). An install that saved settings before 1.7 keeps every value;
if it was on Normal, it now reads Classic, so it is not "edited" against the new Normal. An
install that used Project Sentinel without ever changing a setting (settings are saved only when
one changes; its runs, cache memory or Quest log show it is not new) is saved as Classic, so nothing
changes for it either. A fresh install reads plain Normal.
Guardrails now defer to Claude Code. Once, at the first load after the update, an install whose
permissions are still exactly the old built-in Ask/Deny set, under Normal or Classic, moves to
Default and says so once; the old set is the Guarded profile (Setup), if you want it back.
Values you changed, the stricter profiles (Frontier Max, Low Resource, Release / QA) and your own
profiles are kept. A stored value that cannot be read is read as the stricter one, never as a
looser Default.
How the systems interact
Conflicts are resolved in a fixed order (higher wins):
- Organisation and engine safety: managed settings, deny rules, plan mode. Never loosened.
- Permissions: apply to everything, including work the Autopilot or the guard asked for.
- Your live actions: an interrupt cancels pending automation. A prompt you type while a
handoff is pending is honoured, with a reminder. While a handoff is under way, an instruction about
it ("handoff now", "keep waiting", "cancel the handoff") is acted on and never sent into the old
context; any other message while a written handoff waits is asked about: hand off and give it to
the fresh context, send it here, or keep it in the prompt box. - Autopilot: once a handoff is pending, the guard stands down, and no new large work is
encouraged. Keep warm stands down only once the old context is about to be cleared, and while the
fresh one resumes (a waiting, stuck or checking handoff keeps the cache warm). Queued work,
answers and watcher wakes wait until the handoff is done (work queued for after the handoff
rides the fresh context's first message). Autopilot acts only on a context size Claude Code
reported for the context it is in; a handoff loop it prevented, or a window change it cannot
explain, holds it until you choose. - Operations: Project Sentinel starts a turn of its own (queued work, an answer, a watcher's
wake) only at a boundary, one at a time, and never while a turn runs, a handoff is under way, a
question is open or background work will bring the turn back. A watcher never clears a run that
moved since it was armed. At a run budget limit set to Ask or Finish, none of this (nor
Autopilot's continuation) starts without your yes. - Machine load: constrains how (parallelism, heavy jobs), never whether. It applies
under Frontier Max too. - Subagents: hard limits that Frontier Max and the Agent Model Policy cannot exceed.
- Lazy-exit guard: subordinate to everything above and to its own caps.
- Agent Model Policy: sets a subagent's model at its start, and nothing else; never where
Claude named a model in its Agent call, for a fork or for a workflow's agents. Nothing in Project
Sentinel switches the main conversation's model: a switch is yours, confirmed first while a large
cache is warm. - Focus view: presentation only. It never changes what Claude reads.
Overview shows each system's effective state, for example "Lazy-exit guard ● On Paused
during the handoff".
Security and privacy
Project Sentinel runs entirely inside Claude Code. It makes no network requests of its own,
sends no telemetry, and nothing leaves your machine through it. It observes session figures
(context, cost, each request's token counts), tool calls as they happen, and machine-wide CPU and
memory totals (while the status bar shows them or a machine-load limit is on), and the plan's
rate-limit windows Claude Code reports. In the terminal it runs one read-only git status after a
turn and keeps only the branch and counts. When a milestone is completed it runs git hash-object --no-filters on the files that milestone's work changed (no filters, so no command a repository
configures runs) and git rev-parse HEAD, and keeps only the blob ids, sizes and times. At a
handoff it runs the same git hash-object on the handoff notes file, to tell whether the notes
changed since the handoff began. It writes only
its own plugin store, and once, after the rename, reads the store it kept as Control Room to
carry your settings over (it reads CLAUDE_CONFIG_DIR, USERPROFILE and HOME only to find it). Claude, not the plugin, writes the handoff file. Where Claude Code has
no task list of its own, Project Sentinel offers Claude one small tool, milestones, whose answer
only records the list for run progress; with the Decision Inbox on (the default) it offersdecision_request, whose answer only records the question for you. It never answers a permission
prompt for you. It runs Claude Code's /model only when you press Switch back (after a model
switch over a warm cache, or on a window change Autopilot holds, also /cr window back), and/advisor only when you choose an advisor; /advisor saves your choice in Claude Code's user settings (advisorModel), which Project
Sentinel reads back. With the Agent Model Policy on (off by default) it sets a subagent's model at
its start, and nothing else.
The orchestration layer keeps what you give it with the run, in the same store: queued work in your
words, Claude's decision questions and your answers, watcher labels and times, the run budget, and
Claude Code's own cache-write price per model (for the Cold Resume Guard's figure). It submits
prompts only of fixed kinds, at a boundary: your queued words, your answers, a watcher's wake, the
first prompt of a fresh context it started. When you press them, Stop and Message on an agent
use Claude Code's own TaskStop and SendMessage, and the Cold Resume Guard's Cancel puts your
message back in the prompt box (Claude Code's $.prompt.fill); a message it could not put back is
kept in memory only, never stored.
Three features send requests to your configured model through Claude Code's own client, as every
turn does: the guard's optional smart check (the last request and answer); the Handoff Supervisor's
one question about a background task it cannot recognise (that task's command and description
only, never the conversation); and Keep warm,
which is off by default and, when you turn it on, re-sends the conversation's last request with a
one-word reply asked for, so the prompt cache stays warm. Each refresh costs tokens, mostly cache
reads at a tenth of the input price.
What it observes, what it can change and what it never does is listed in SECURITY.md;
the plugin folder's README says it in brief, as Anthropic's
directory shows it.
Compatibility
| Status | |
|---|---|
| Claude Code 2.1.293, terminal CLI (Windows 11) | Verified live with real models (Sonnet 5.5, Opus 5.5): Autopilot end to end (four runs: threshold crossed mid-turn, the handoff turn, notes verified, /clear, the fresh session, the continuation, milestones and objective carried, one handoff where a low threshold used to loop); Keep warm on the 1-hour and the 5-minute cache, its self-check verified, its figures identical to Claude Code's own prompt_cache; a model switch confirmed first and its rebuild named as Claude Code names it; policy and effort changes while warm. The 1.3.0 status bar with Kit and every panel section in a real console at 80, 100 and 150 columns during a scripted turn from the demo driver. 1.4.0 (Haiku 5.5, a frozen test copy): a live Autopilot handoff whose fresh context received its notes as a context block and finished the task; Kit through a scripted demo turn and answering clicks in a real console; the cache at the plan's one-hour default from the first request. |
| Claude Code 2.1.295, CLI (Windows 11) | 1.5.0 verified live with Sonnet 5.5 through a recording proxy (fingerprints and token counts only): Keep warm on the 5-minute and the 1-hour cache, each refresh then VERIFIED by the conversation's own request, and a control without it rebuilding; Frontier Max with its effort in the first request of a session, turned on and off mid-session, after /clear, after a compaction and across a reload; the Autopilot chain with /clear and with compaction, a prompt queued mid-handoff, a reload mid-handoff and the guard standing down. A clean install into a throwaway configuration; the update from 1.4.1 and a fresh terminal session as a user (panel, status bar, Kit off and on, a head pat, the model switch asking first). |
| Claude Code 2.1.295, CLI (Windows 11): 1.6.0 and 1.6.1 | The orchestration layer verified live with Sonnet 5.5 through the recording proxy, on a renamed test copy. Mission Queue: /cr queue while idle went as a turn of its own; typed during a turn, Claude Code ran the command when the turn ended and the item went once, after it. Decision Inbox: Claude left a blocking decision with decision_request, /cr decisions listed it, /cr decide D-1 Spaces answered it and Claude acted on the answer. Watchers: one woke the run in its context at its minute; one stood down because a turn ran after it was armed (nothing sent, nothing cleared); one due while Claude Code was closed waited for the person when the session was resumed; a Fresh wake ran /clear and the fresh context, given the run's milestones and notes, finished the check. Cold Resume Guard, in a real console on a resumed 90k-token session whose cache had lapsed: Claude Code's dialog asked before anything was sent; Cancel put the message back in the prompt box and no request went; Continue sent it. |
| Claude Code 2.1.295, CLI (Windows 11): 1.6.2 | A live pass over each orchestration system with Sonnet 5.5 through the recording proxy, on a renamed test copy, fixing what it found (see the changelog). Cold Resume Guard on a resumed 185k-token session past its 5-minute cache: Start fresh sent one fresh request (2 messages) carrying the message once, and the fresh context continued the milestones with the queued work; Compact first compacted 185k to 2.9k tokens, then sent the message once. Agents: Message reached one background agent and not the other, Stop stopped one, and both survived a reload of the plugin. Run budget: Notify, Ask (queued work held until /cr budget continue) and Finish (Claude finished the milestone under way and stopped). Watchers: Keep warm held a 145k cache for 12 minutes and the wake read it all from the cache; with the refresh refused by the API, Smart woke fresh and Keep warm waited for the person. One integrated run with all of them, 5 of 5 milestones across a fresh wake. |
Claude Code 2.1.295, headless stream-json (Windows 11): 1.6.3 |
A handoff whose turn ended while a background render still ran, driven live with Sonnet 5.5 beside an event probe: 1.6.2 stayed in writing the handoff after the render's notification turn ended (reproduced); 1.6.3 waited for the render, took its result into the notes, then checked them, cleared and continued in session 2 by itself, one handoff prompt, one /clear, one continuation. /cr handoff and /cr fresh said what was true at each point. |
Claude Code 2.1.296, CLI and headless stream-json (Windows 11): 1.7.0 |
Driven live with Sonnet 5.5 on renamed test copies: a server and a 10-minute render behind a written handoff on a 5-minute cache (the server not waited for, Keep warm refreshing through the wait and verified by the render's turn, standing down only at the notes check); a build past its wait left running and its result recorded in the fresh context; "handoff now" typed while waiting; an unrecognised task sent once to the isolated classifier; a milestone's evidence going stale and re-verified; background agents, a workflow's agents and a reload mid-agent in a real terminal with the band and Activity › Agents; a fresh install's first run; five-hour readings from 46% to 59%. The Desktop app itself was checked through tools/desktop-preview only. |
| Claude Code 2.1.325 and 2.1.289: 1.8.0 | The test suite on both engines (654 tests on each locally, type-checked against 2.1.289's own declarations too; in CI on the latest Claude Code for Linux, Windows and macOS and on 2.1.289 for Linux, all passing), with one run across three fresh contexts with everything at once (tests/chaos.test.ts) and replays of the long-run failures it fixes (tests/repro.test.ts: 18 of its 19 tests fail on 1.7.0; the 19th is a control). Live on 2.1.325, headless, on a renamed copy (Haiku and Sonnet only): /cr models, /cr advisor, /cr router, and the advisor setting read back; an SDK set_model switch (as Desktop's picker makes it) reaching the guard as source: sdk, and the request-level check before the next request; the Agent Model Policy running a review subagent on Sonnet under a Haiku session, with its effort, result and Resume; a finite background job left running past the handoff's patience across a real /clear, its end recorded in the fresh context, with no carried-over size. Not verified live: the Desktop app (its renderer only, through the preview), the model-switch question itself (a headless session has nobody to ask), a Fable session or a real 1M → 200k window change (synthetic only), a multi-hour job, and setting the advisor (it would change your own settings). |
| Claude Code 2.1.289 and 2.1.292 | Verified: the test suite run on their engines, type-checked against their declarations, live headless runs in the Desktop host protocol (1.2.0 and earlier) |
| Continuous integration | On every push and pull request: type-check, strict validation of the plugin and the marketplace, the source rules Anthropic's directory reads, and the tests, on Linux, Windows and macOS with the latest Claude Code, and on Linux with 2.1.289 |
| Claude Desktop Code tab, visual | 1.0.1 and 1.0.2 reviewed in the app (the screenshots above are 1.0.1); 1.2.0's status bar seen in the app (its white bar and overflow are what 1.3.0 fixes). 1.3.0 seen in the app (Claude Desktop 2.26454): the person's review of a release candidate, then the status bar's four cells, Kit and Overview captured read-only from the app's window. 1.4.0's release candidates installed in the person's app (Claude Desktop 2.26454, Claude Code 2.1.293) and captured read-only: the update from Control Room (a session open during it keeps Control Room while Project Sentinel stands by; a fresh session runs Project Sentinel alone, with the settings, runs and cache memory carried over and its run continued), Kit animating through a turn, and the five cells with the Machine cell at two widths. Kit's touch was not tried in the app (the app's window is never clicked). Every layout is also checked on the desktop surface in the harness and with tools/desktop-preview, which renders with the app's own layout rules. 1.5.0's Kit was refused by the app's page (seen in the app: its image gave no width, which the page requires of a surface module); 1.5.1's Kit trees pass the page's own check, run from the app's bundle. 1.6.0's Operations, its chips and the sleeping status bar are checked on the desktop surface and in the preview; they have not been seen in the app yet (1.6.2's live pass could not look at the app either). 1.8.0, before its release, seen in the app by the person (its Claude Code 2.1.325, a narrow docked panel): the Models card, Run progress and the status bar in a session that picked the build up in place; the model cut to haik… there is fixed, tested on the desktop surface and seen in full in the app (Haiku 5.5). A session open through the update kept the version it started with (see Troubleshooting). |
The milestones tool with a real model |
Verified live: Sonnet 5.5 kept outcome-level milestones ("Temperature module", "Index re-exports and README") and carried them, with the objective, across handoffs. Answer styles are tested through the engine only. |
| macOS and Linux machine-load sampling | Implemented and unit-tested against real top, sysctl and /proc output. Not yet run live. |
| Mobile and VS Code surfaces | Draw (mobile opens choices in place, as in the terminal; VS Code shows Kit's pose still). Not reviewed visually. |
| Older Claude Code | Loads with a notice below 2.1.289. Features may not work. |
Limitations
- Advisory machine load. Project Sentinel informs Claude and holds back additional heavy commands.
It does not and cannot enforce an OS-level CPU or memory quota, and it never stops or changes
other programs. - Pattern-based shell classification. Permissions narrow what Claude may do. They are not a sandbox.
- Run progress counts what Claude lists. With no task list (or Behavior → Run progress off)
there is no work meter. A check passed when its command did; a command sent to the background has
no outcome Project Sentinel can see, and says so. - Subagent models are aliases. At a spawn Claude Code takes
haiku,sonnetandopusand
resolves them; Fable is set only once Fable has been seen answering in the session (until then
the agent keeps its own model). The main conversation's model is never set by Project Sentinel. - Model, effort and thinking as Claude Code reports them. A switch from Desktop's model picker,
Remote Control or an IDE comes with no dialog Claude Code documents, so it is caught at your next
message, not before. No event announces an effort change before a request, so effort is seen at
the request. Thinking settings are not documented either way: traced, never guessed. A model alias
and an id of the same family may name the same version: never asked about. - The advisor's models are Claude Code's to name. Its command list gives plugins no list of
models, so the documented ones are offered as unconfirmed, and Claude Code's own/advisorsays
if one is not available. A model set for one launch with--advisoris not in the settings, so
it is not seen. - The window sanity guard has been tested with synthetic telemetry only. Claude Code 2.1.323
changed the window it assumes for a model it does not know from 200K to 1M; an older bundled
engine likely read Fable 5.2 as 200K, the case the guard is for. - Headless runs. With no one to answer, a call set to Ask is refused. In CI or
claude -p,
set categories you need to Default. A plugin command such asclaude -p "/cr status"given as
the initial prompt goes to the model, because plugin commands register as the session starts.
Use an interactive session, stream-json input, or the panel. - Managed machines. Where your organisation seats Claude Code's managed policy guard,
Project Sentinel's system-prompt section can be skipped. It detects this and delivers its
policies as prompt context instead. - No global sidebar and no pinned header. There is no API to change the Desktop application's
own sidebar, or to pin a region inside a pane. The docked panel is the supported equivalent, and↑ Sectionsbrings the section bar back from the end of a page. - The prompt cache is read, not reported. Claude Code reports how many tokens each request read
from the cache and wrote to it, but no expiry, hit ratio or miss cause. Project Sentinel derives
them: the expiry from the last request and the lifetime (as Claude Code is configured, byFORCE_PROMPT_CACHING_5M,CLAUDE_CODE_PROMPT_CACHE_TTL,promptCacheTtlorENABLE_PROMPT_CACHING_1H; as it reports it at a model switch; or learned; a claude.ai plan
otherwise starts at its one-hour default), the cause from the change it
saw before a rebuild, said as proven, likely or unknown. A rebuild with nothing seen before it reads
cause unknown, never put on the server without evidence. Only the main conversation's cache is
watched; subagents start their own. - Git in the terminal only. Desktop shows Git beside the session, and no plugin API reaches that
strip, so Project Sentinel does not repeat it there. - Watchers live in Claude Code's process. A watcher is a timer in the running Claude Code: closed
(or the machine asleep), nothing wakes. It is kept with the run, and when that session is open
again an overdue watcher waits for you (Watcher was due 43 minutes ago, Wake now); it does
not wake by itself then. Project Sentinel installs no daemon, service or scheduled task. Claude
Code's ownCronCreateandScheduleWakeupare session-only too; its cloud routines start other
sessions, not this one. - The Cold Resume Guard asks in Claude Code's dialog. Where no one can be asked (a headless run),
it does not ask and the message goes. It knows a cache has lapsed from the lifetime it learned, an
hour of quiet (longer than any lifetime), or Claude Code's own word at a resumed session; a cache
that may still be warm (Claude Code's own requests while you are away count) is never called
cold. It leads with tokens; a dollar figure is only Claude Code's estimate for that model (seen at
a model switch or a resume), said as a floor: the reprocessing has cost more than the estimate. - Background work across
/clear. Claude Code keeps a background task running across/clear
and hands its result to the fresh context (verified live), so a handoff never waits on a server
and waits on finite work only so long (20 minutes by default). It cannot know what an unrecognised
task is: it waits for it, asks a small classifier once, and you can always hand off now. - Five-hour usage is Claude Code's last reading. It moves when a response brings a new one (and
is read again each minute while a window counts down). Usage from other sessions or devices shows
only when a response of this one reports it. - Milestone evidence watches a milestone's own files. The files its work changed and the outputs
Claude named; a file its checks depend on but its work never touched is not watched (that would mean
hashing the repository). A file changed by a command whose changes Claude Code does not report counts
as changed outside Claude's tools. - Agents as Claude Code reports them. No cost per agent and no context usage per agent (Claude
Code reports neither; each subagent compacts its own context, and those compactions are shown);
Stop and Message only where Claude Code'sTaskStopandSendMessagetake the agent
(background agents and teammates); Resume only for a subagent this session saw finish. Claude
Code exposes no max-turns flag, so a stop at a turn limit cannot be told from another stop.
Decisions from subagents are not taken: the inbox is the main conversation's. Project Sentinel never
runs a handoff inside a subagent.
Development
plugins/project-sentinel/ the plugin, and only the plugin (Anthropic's directory reads every file in it)
.claude-plugin/plugin.json manifest; icon.png beside it
README.md, LICENSE the directory's listing and disclosure; MIT
hooks/hooks.json { "modules": ["./register.tsx"] }
hooks/register.tsx the Host adapter and every hook registration (the only file that touches `$`)
hooks/kit.client.tsx Kit's surface module, drawn in the terminal and on Desktop
hooks/app/ Runtime (composition root), views and status wording, publisher, commands, persistence,
monitor, cacheGuardian (the prompt cache and Keep warm), formerStore (the rename)
hooks/core/ settings schema and defaults, profiles, policy, answer styles, formatting
hooks/features/ autopilot, contextEpoch (each context's own size), handoffArtifact (the verdict
on the handoff notes), background (what a background task is), dependencies
(background work across contexts), supervisor (the Handoff Supervisor), intent
(handoff-control words), chain, guard, agentModels (the Agent Model Policy),
modelGuard (the model and effort cache guard), advisor, subagents,
agents (the agent ledger), activity, plan (run progress), evidence (milestone
evidence), planUsage (the five-hour window), validation (checks), digest
(Activity's signal), quest (the Quest log), cache (the cache model), handoff
(Handoff Health, Continuity), companion (Kit), git, prompts, permissions/, resources/
hooks/ui/ design system (primitives, theme), status bar, Focus view rows, panel sections
types/index.d.ts the plugin's $.state contract
tests/ claude plugin test suites (run on .build/mod: the plugin with tests/ beside hooks/)
tools/
test/ mod.mjs (assemble, type-check, test), validate.mjs (validate the plugin as it
ships), source.mjs (the directory's source rules), snapshot.mjs (a frozen
cr-test copy for live tests)
desktop-preview/ the status bar and the panel as Desktop lays them out, rendered as HTML
console/ Windows only: drive Claude Code in a real console, read the screen, save a PNG
demo/ development only: a scripted turn of real tool calls, no model, for screenshots
npm install
npm run check
npm run check runs tsc, claude plugin validate --strict (plugin and marketplace; the plugin
from a copy without the type declarations laid for development, as it ships), the source rules and
the test suites; CI runs the same on Linux, Windows and macOS.
Claude Code writes the engine's type declarations intoplugins/project-sentinel/.claude-plugin/types/ whenever a session loads the folder. Load it once
(claude --plugin-dir plugins/project-sentinel, then /exit) before running tsc. See CONTRIBUTING.md for the rules the code follows and
docs/DESIGN.md for the design system. On Windows,
tools/console runs a session in a real console of a given width and
reads the screen back, for checking the terminal UI.
This repository is a Claude Code plugin marketplace (.claude-plugin/marketplace.json, namedcontrol-room). The plugin folder is laid out for Anthropic's plugin directory (its listing text,
licence and icon inside it); a submission is the maintainer's to make.
License
Yorumlar (0)
Yorum birakmak icin giris yap.
Yorum birakSonuc bulunamadi











