Developer Guardrails
The machine-wide sibling of Git guardrails: a set of rules written into your global Claude Code settings so every Claude Code session Omniscio starts — subagents included — is held to them however it was launched, with escape hatches and a warn-only mode.
What it is
Status: shipped, OPT-IN (default OFF). Turn it on in Settings → Features → Developer guardrails (machine-wide). Because it edits your GLOBAL
~/.claude/settings.json, it stays opt-in — nothing is installed until you flip it on, and turning it off removes it cleanly. Cross-platform (Windows / macOS / Linux).
Developer guardrails is the machine-wide sibling of Git guardrails. Where
Git guardrails protects the sessions Omniscio spawns (wired per-session at launch, on by
default), Developer guardrails protects every session Omniscio starts, from one safety hook
installed into your GLOBAL ~/.claude/settings.json.
It's the built-in, one-switch, cross-platform version of the hand-installed "block-master" hooks some power users wire into their global config by hand: instead of maintaining your own scripts, Omniscio deploys the check and keeps it healthy for you.
A session Omniscio did not start is not guarded
Changed 2026-11-10. A plain claude you start in a terminal — or any other tool's session —
is a Claude Code session with no AMC_SESSION_ID, and that pair is the whole boundary. The git
rules stand down for such a session — edits on master, the shared-store rules, destructive git
verbs, the whole-drive search refusals. Two rules that do not depend on a branch still refuse: it
will not print or overwrite the Omniscio full-trust key, and it will not switch gcloud's default
Google account. One other refusal also still applies, because it is a separate hook: asking for a
native worktree (EnterWorktree, or an agent with worktree isolation) is refused, since every
worktree must be born through Omniscio's registered pool.
The same boundary covers the two other guards that reach a shell on this machine: the ~/.bashrc
routing block defines no wrapper and adds no PATH entry for such a session, and the git-authority
hook allows it. A session with AMC_SESSION_ID — everything Omniscio starts, subagents
included — is guarded exactly as before, and the app's own git processes (which carry neither
variable) keep their guard.
The reason is the one you would guess: every other way to lift a guard needed Omniscio running, so
whenever the app was down a plain session had no road out at all — it could not even clear a stale
.git/index.lock. The trade is deliberate: an outside session now has your full machine access,
including one reading a hostile instruction. Turn Developer guardrails off entirely if you want no
hook installed at all.
It reuses the Git guardrails engine — it does not re-implement the rules. The same classifiers that power the per-session feature are shared, so the two behave identically on the rules they both enforce.
It is a safety rail, not a security sandbox — the same caveat as Git guardrails. It catches the common, honest cases; a determined agent that deliberately obfuscates a command can evade a shell-command checker.
Where to find it
Escape hatches (shared with Git guardrails)
The guard reads the same override files as Git guardrails (the hand-installed PowerShell
guards read the approval window and the exclusion list), so one grant covers all of them. It reads
them by calling the engine's resolveGrantKind — the one grant rule every delivery shares — rather
than by deciding for itself which of them a call may see:
- Pause — a time-boxed window in
~/.claude/.master-approval.json. While active, everything is allowed. A window counts only in the shape its writers produce — the app's Approve button and the machine's own command-line opener — stamped, with its grant time and a length of 1 to 240 minutes. A longer or hand-shaped window is refused outright, never shortened to fit. - Scoped to one agent — the marker names a single agent session. That agent gets through; every other agent on the machine stays blocked for the window's whole life. A window opened for a specific session carries that session's id; one opened from a plain terminal carries the empty string, which every reader fails closed on, so a terminal-opened window covers non-agent git work only and every agent stays guarded. Only the app's own "Pause for N minutes" writes a window with no name, which is still machine-wide.
- Pause one agent — a human's per-session pause in
~/.claude/.guardrail-session-pause.json(the inbox Approve) lifts the rules for that one agent only, read with the same shape test. On both guards it also lets that agent edit the owner's own hook files under~/.claude/hooks— never the installed guard bundle or the grant files, and an agent's own pause never does. - An agent's own short pause —
~/.claude/.guardrail-self-pause.json, written when an agent callsPOST /git-guardrails/self-pause. Capped at 10 minutes and budgeted to twelve per hour. It is deliberately NARROWER than a human grant: it does not lift agit push, a destructivegit stash, a forced worktree removal, or a destructivegit remoteverb, and it can never reach the approval files themselves. The guard passes the grant's kind to the engine's classifiers rather than a yes/no, which is what keeps that narrower scope intact — seegit-guardrails-invariants-self-pause-grants-and-override-contractin the repository's.claude/memory/contracts/. (Honoured since 2026-10-02. This guard — the machine-wide one — was the exception until 2026-10-12: it derived its own grant from the approval window and the human per-session pause and never asked the self-pause question at all, soPOST /git-guardrails/self-pauseansweredok: truewith a live expiry and the very nextgit commitwas still refused. The typedCLAUDE_ALLOW_MASTER=1prefix was unreachable here for the same reason. Both entries now resolve the grant through the engine's one shared rule, and each self-opened road — the self-pause and the typed prefix — is reported as the AGENT's own rather than as a window a person opened.) - Exclude a repo — a per-repo list in
~/.claude/.master-block-exclusions.json({"repos": ["C:/path/to/repo", …]}). A listed repo (or one nested under it) is never guarded. - Grant one push — a PR-push grant in
~/.claude/.push-approvals.jsonlets one plain, non-force push of one branch at one commit through without a ready-to-merge tag, exactly as Git guardrails honours it. The hand-installed PowerShell guards do not read this file. - Put master files back while the app is down — every grant above is written by the app, so
when Omniscio cannot start none of them can be opened. The emergency restore road covers the one
repair that case needs: it restores the named files on master to their last-committed
content, and only after the person said yes in chat.
It refuses while the app's control port
answers or its heartbeat names a running app, so it never helps while a grant could be asked
for. A refused
git restoreon master names it, in a checkout that ships it. Details: git-guardrails.md.
None of these lifts a command-safety rule. The window, both pauses and the repo exclusion lift the git rules only. The command-safety rules — a heavy local test run (
slow-local-test), an app restart, a mass PR close, an unscoped process kill, whole-tree staging and their siblings — and the hard rules (a whole-bucket cloud-storage listing, a default cloud-account switch) refuse whatever is open. Their refusal says so in its last lines and names the repo and branch it judged, so the way forward is the one in the refusal's reason, not a grant.slow-local-testonly applies inside an Omniscio checkout; a run in any other repo is not refused — even one that has its owntest:agentscript, one reached throughcd "$WT" || exit 1from a multi-line script, or one wrapped in( … ). A run a command MOVES into another project is judged on that project, not on the folder the shell happens to stand in: npm's--prefix, pnpm's-C/--dir, yarn's and bun's--cwd, and vitest's--root/-r. A flag the program in front does not implement moves nothing (npm has no--dir), vitest's--dirmoves only the folder it scans, and everything after a bare--is the script's own argument — so those keep the refusal in this checkout. When the guard cannot tell which folder a run lands in (acdto a variable it cannot read, say), it refuses and says so:cdthere by its literal path in a separate call, then run the tests. Inside Omniscio, wrapping a run does not get it past the rule:timeout,env,nohup,exec, a redirect,npm run-script test,bash -c "…"and$( … )are all read.
These files are guarded against the agents they constrain. An agent tool call that writes any of them — or the deployed bundle in
~/.claude/hooks/developer-guardrails/— is refused, through the edit tools and the shell alike, and refused even while a window is open so one approval cannot authorize the next. Reading is still allowed. Added 2026-08-25 after a blocked agent was found writing its own approval window and retrying the edit:~/.claudeis not a git repo, so the protected-branch check never applied to it.What this does not close: a write the guard cannot see — a script or helper program that writes the file itself — can still leave one of these files behind, and the stamp on a window is its shape, not proof of who wrote it. The write rule covers the one-command routes an agent uses; it is a guardrail, not a sandbox.
How it behaves
What it blocks
When enabled, these operations are gated in every Claude Code session Omniscio starts — however it was launched. A session Omniscio did not start is not gated on these git rules, but rules 9 (the full-trust key) and 10 (the gcloud default account) still refuse it, and the separate native-worktree hook still refuses native worktree creation:
- Commit / write while on a protected branch (
master/main) —commit,reset,rebase,merge,cherry-pick, a branch delete, etc. - Push that targets a protected branch — e.g.
git push origin master, from any branch. - Destructive
git stash—push/pop/drop/clear/apply/saveand baregit stash. Read-onlygit stash list/showare allowed. - Editing a file while the repo is on a protected branch — the same rule as #1, for the
agent's file-editing tools. One exception: a working file under the repository's own
audit-reports/folder is allowed when git ignores it, because that is where Nighty Tidy audits keep their state, scope and findings in the main checkout. A sibling folder, a path that climbs out with.., a link that points elsewhere and a tracked file there all stay refused. - A shell command that writes a file into a protected checkout — the shell half of #4
(a
>redirect,curl -o,tee,cp/mv, a PowerShell write cmdlet). Gating only the edit tools left an obvious way around them, and it is how stray untracked files end up in a repo root. Tuned to stay quiet — it stands down on anything it cannot resolve ($TMP,~/x, a>inside quotes or a script body) and on files the repo already ignores. - Destructively closing pull requests — a bulk or scripted close is refused outright with no override; closing one needs a marker naming that exact PR.
- Killing or restarting the app from a shell — the shell path around the restart gate the app already enforces. Tidying up your own dev instance is untouched.
- Scheduling a task that pops a console window — caught at creation, because the repair job cannot save a one-shot task.
- Printing — or overwriting — the full-trust CLI key — the master key at
~/.amc/cli-tokenmust never reach a tool result, and must never be clobbered. AReadorGreppointed at that file (or at the.amcdirectory holding it) is refused, as is aWrite/Editonto it (a model that hit a 401 and decided to "repair" the token file would otherwise break every agent's auth on the box), and so is a shell command naming it outside a$( … ). The same value has a second door, and it is closed too: the OS keyring holds the identical token, so reading the key out of it bare is refused as well. A capture that only puts the value in a variable is allowed, because putting it in a variable is not printing it. The one form agents are taught is the helper,node "$HOME/.claude/skill-content/omniscio-control/amc-api.mjs" <METHOD> <route>, which never names the key file at all (see "The deny rule also refuses a shell read of the key" below). The older substitution forms —-H "Authorization: Bearer $(cat ~/.amc/cli-token)", or assigning it to a variable inside the same command — print nothing, so THIS guard still allows them, but Claude Code's own deny rule refuses them whenever it can analyze the command, so no doc teaches them any more; a substitution whose value is only passed to a program is allowed by this guard too. Inside a command the key may only be CAPTURED or SENT — and once it is captured, that is the only thing the REST of the command may do with it. A capture followed by an unrelated command (TOKEN=$(cat ~/.amc/cli-token) && git status) is refused, because an arbitrary command after a captured key cannot be shown to be safe; send the value in a header instead. A loop around the send is fine:TOKEN=$(cat ~/.amc/cli-token)followed byfor k in a b; do curl -H "Authorization: Bearer $TOKEN" …; doneis allowed, because the loop's ownfor … in …,doanddonerun nothing — its body is held to the same rule, and a loop header whose word list expands anything ($T,$( … ), a glob) is refused. The client may be spelled however the shell runs it —curl,curl.exe,/usr/bin/curl, or PowerShell'sirm. Anything else is refused —echo,printf,sed, a display cmdlet, an interpreter, a debug flag, a verb the guard does not recognise — because a form that cannot be shown to be safe is not assumed to be. The two substitution shapes this guard allows areTOKEN=$(cat ~/.amc/cli-token), and-H "Authorization: Bearer $(cat ~/.amc/cli-token)"oncurl,wgetorInvoke-RestMethod; every refusal names the helper instead, because the harness refuses those shapes on its own. A client is only trusted when the key is actually sent — the header form above; merely carrying it, as incurl $(cat ~/.amc/cli-token), is refused, because curl echoes a URL it cannot resolve back into the model's view. A flag elsewhere in the command is not the same as the key being in it, socurl -H "Accept: x" "$(cat ~/.amc/cli-token)"is refused too: the key has to sit in the flag's own argument. A quote, a backslash, a PowerShell backtick or bash's ANSI-C operator ($'\x63') inside the path is caught too — the guard reassembles the word the way the shell will before it matches, and it does that on every call, with no cheaper pre-check that a spelling could slip past. The debug flags that echo a request are refused per client (curl -v,wget -d,Invoke-RestMethod -Debug), and a captured key that a later command dumps back out (printenv,set,envwith no argument) is refused too.curl -vis refused: its debug output prints the outgoing request line, header and all. This one exists because the key reached a dozen transcripts through a barecat, acat … | head -c 20"to check it exists", and a Read on the file. The value is guarded too, not just the file: a call carrying the key's actual value —curl -H "Authorization: Bearer <the value>" …— is refused as well, because a call's own arguments are recorded even when the command prints nothing, and nothing in that text names the file the guard was watching. It applies to every tool, so a command, a file body being written, or a search pattern all count. The guard reads the key itself to do this, in its own process, and never puts it in a result. One known over-refusal, on purpose: PowerShell's natural capture,$token = Get-Content ~/.amc/cli-token, assigns rather than prints and so is refused too — the guard masks bash's$( … )and PowerShell needs no subexpression for a capture. Use the helper instead — it runs unchanged in PowerShell; the CLI control guide teaches that form. - Switching the computer's default gcloud account (
gcloud-default-account-switch). An agent's shell command that would change which account gcloud uses by default is refused:gcloud auth activate-service-account,gcloud auth login,gcloud auth revoke,gcloud init,gcloud config set|unset account(orcore/account), andgcloud config configurations activate|create(unlesscreatehas--no-activate). The default account is the person's own login, and every publish, deploy and read that runs as them breaks when a robot account replaces it (2026-10-14: one activation broke share publishing overnight). Two forms stay allowed: a command that points gcloud at a separate settings folder (CLOUDSDK_CONFIG=~/.amc/gcloud gcloud …, anexportof it earlier in the same Bash command, or$env:CLOUDSDK_CONFIG='…'earlier in the same PowerShell command), and any read that names its identity per command with--account <email>. The rule reads the command the way the shell will run it: a pin written in the other shell's syntax, a pin laterunset, a pin to the default folder in any spelling ($APPDATA/gcloud,/c/Users/…/AppData/Roaming/gcloud, an empty value, an unset variable), and a switch hidden insideif/then/do/{ },bash -c/-lc,eval, a$( … )or a wrapper such astimeoutare all caught; a line it cannot parse is refused. Everyday gcloud (auth list,print-access-token,config set project,compute …) is untouched. Out of scope: a script that spawns gcloud itself (the cloud code's own isolation layers cover those) andgcloud auth application-default login, which changes the ADC credential rather than the default account. - Rewriting the shared git store — five rules (
store-rewrite-verb,store-rewrite-config,protected-ref-delete,nonhead-ref-deleteandgit-dir-write), the same ones Git guardrails enforces and lists as #23–#26 on part 2 of its page. Every worktree on the machine shares one object store, so an agent is refused the git commands that rewrite it (gc,prune,repack,reflog expire,commit-graph writeand the like), settings that switch that cleanup on (gc.auto=1,fetch.prune,maintenance.auto), deletingmaster,mainor any tag, remote-tracking ref or other ref outside the branches, and deleting, moving or overwriting a file inside a.gitfolder — withrm,mv,Remove-Item,del, a redirect, anode -eorpython -cone-liner, or the Write and Edit tools. This holds in every Claude Code session Omniscio starts, however it was launched. Reading.gitand copying from it stay open, and a throwaway repository under the temp folder is exempt. The hook reads the git calls inside a script file the command runs, and the repository's saved aliases, the way the per-session hook does. Deleting the.gitentry itself is the separate repository-store rule on Git guardrails (#19). - A recursive delete outside your own folders (
recursive-delete-outside-workspace). Added after 7 November 2026, when a Codex session's misquotedcmd.exe /c rmdir /s /qlanded on the root of drive F: and emptied the shared node_modules store and 45 worktrees. A recursive delete —rmdir /sorrd /s,Remove-Item -Recurse(andrm -rin PowerShell),rm -r/rm -rf, or a Nodefs.rmwithrecursive: true— is refused when its target is a drive root, theUsersfolder, your user folder or one of its top-level folders (Desktop, Documents, Downloads, OneDrive, AppData, and AppData\Local and AppData\Roaming themselves), or anywhere outside the session's own working folder. Deleting inside your working folder, inside temp folders, inside the per-user app caches below AppData\Local and AppData\Roaming, inside the launcher's own store in the patch road's tools cache (theamc-patch-tools-v<N>-<your account name>folder under<drive>:\ProgramData\Omniscio\patch-tools-cache, where its background prune retires idle copies), inside the app's run-folder store at least one entry down (<drive>:\ProgramData\Omniscio\run-folders\<owner>\…, where a scratch copy of a checkout is swept after its hand-out), inside the shared node_modules base store the app's seeder builds and retires (<drive>:\.amc-nm-base\…, the dependency tree your run folders and worktrees link into), and inside the machine's shared scratch folders (such asAMC-Scratchat the top of a worktree drive, the same list the app's scratch cleanup uses) stays open; the scratch folder itself, thepatch-tools-cachefolder itself, a folder inside it that is not the launcher's own store, therun-foldersfolder itself and a whole owner store inside it, the.amc-nm-basefolder itself, a drive root and a user folder never are. A delete that reaches its target through a link is judged without those app-owned allowances, so removing a worktree'snode_moduleslink still cannot delete the shared base behind it. The guard works out the target the way the shell would — quotes,%VAR%and$env:variables,cd, a bare\— and a target it cannot work out is refused with "spell the full path out". A working folder that is itself a link (a project folder moved to another drive and linked back) counts at its real location too, so a program deleting inside its own checkout by the real path is not refused. It holds on a warn-only machine too, and it reaches past Claude: Codex is asked before it runs a command, and every engine's Node processes carry the same check. Like rules 6–10, a pause does not lift it, and neither does an excluded repo. - A command hidden behind run-time decoding (
decoded-exec). Added 12 November 2026, after a Codex session sent a message throughnode -e "eval(String.fromCharCode(...))"— harmless that time, but no guard could read what it ran. Refused: inline code (node -e/-p,python -c,ruby -e,perl -eand the like) that both decodes text (String.fromCharCode,atob, a base64, hex or byte-arrayBuffer,decodeURIComponent, Pythonb64decodeorbytes.fromhex, Rubydecode64, Perlpack, and their kin) and has a way to run it (eval,Function,exec,systemand the other run calls), even when the decoded text sits in a variable first; a decoder (base64 -d/-D,openssl base64 -d,xxd -r) piped into any shell or code runner that reads its program from the pipe, or wrapped in$( )/<( )thateval,source, a runner or the shell itself runs; PowerShellFromBase64StringorGetStringtogether withiex,Invoke-Expression,Invoke-Commandor[ScriptBlock]::Create; andpowershell -EncodedCommand(or-enc/-e) with a base64 argument. The refusal says: "This command hides its real content behind run-time decoding, so the guards cannot read it. Write the command in plain text." Plain inline code, decoding something only to print it or save it, a decode handed to a script as data (| python3 -m json.tool), and a command that merely contains a base64-looking string are all fine. It holds on a warn-only machine too, and Codex is asked the same question before it runs a command.
Rules 6–10 are branch-independent and are NOT lifted by a pause — rules 6–8 each carry their own one-time override instead, so lifting one is a single deliberate act. Rules 9 and 10 have no override at all: they run before the pause and exclusion files are read, so neither can stand them down.
Rule 11 is branch-independent too, and has one way past it: a person's approval, asked for with
POST /git-guardrails/approval-request, lifts exactly one tool call and only for ten minutes. The
agent's own self-pause, an excluded repo, the typed override prefix and a standing "always allow"
lift nothing there, and a warn-only machine still refuses. If the guard's store files did not install
on this machine, the hook refuses a command that names a store verb or a .git path with a "restart
Omniscio" message rather than letting it through.
Always allowed: reads (git status / log / diff / …), moving onto a protected branch,
creating a branch, and a full git fetch. git worktree add is NOT — a hand-rolled worktree
creation is refused here (rule 4b, raw-worktree-add) on every branch, because it bypasses the
Worktree Ledger: the worktree it makes is never recorded against an owner or a task. Lease one
through POST /worktrees/create on the control server instead — the refusal hands you the exact
curl call to make. That call is not one synchronous act: on a busy box it answers 202 with
status: 'creating' and no path yet, and even a 200 carries a readinessWarning, because
node_modules keeps filling in after the reply. Read that field before you work in the folder.
The only lifts are a human worktree break-glass and the AMC_ALLOW_RAW_WORKTREE_ADD=1
env hatch. A shallow fetch is the one exception: --depth, --shallow-since,
--shallow-exclude, --deepen and --update-shallow are refused on the fetch / pull family,
because a worktree shares the main checkout's object store and the boundary file lives
there — so a --depth fetch typed in a scratch worktree marks the MAIN checkout shallow. That
hides history which is present on disk (measured 2026-10-12: this computer reported itself 220,661
commits ahead when the real figure was 1,499). A shallow clone into a disposable folder is
still fine; this is about the shared store.
git fetch --unshallow is allowed, and deliberately so: it CLEARS the boundary rather than
writing one, and on a repo that is already shallow it is the cure — baseline-drift.mjs tells
agents to run exactly that.
Scope: this rule lives only in the Claude hook. It is enforced by the PreToolUse hook on the typed command, and it is NOT an entry in
SAFETY_GIT_RULES— so the native git shim and other engines do not enforce it, and the shim digest is unaffected. A--depthfetch issued by a CHILD process is likewise not seen, because the hook reads a typed command string from its stdin payload and anexecFileSync/spawnSyncchild supplies none (measured: 0 bytes). That is why the app's own depth fetches —baseline-cloud-fire.mjs'sfetch --depth 2000,session-create-spawn-tail'sclone --depth 1— keep working. The rule guards the agent-typed path, which is the path that wrote the boundary here at 05:02 on 2026-10-12.
The app's own call sites are held separately. Because the hook cannot see a child process, every app-side fetch that carries a shallow-writing flag is listed in app-depth-fetch-register.test.ts with the reason it cannot mark the project repository shallow, and a new one fails that test until it has a row. The post-land build check no longer appears there at all: its fetch into a shared checkout went with the build-net branch, and the road now builds only in a checkout it owns (the auto-lander recovery contract in the repository's
.claude/memory/contracts/). On 2026-11-01 at 22:19 the project repository was marked shallow with one graft by a call nobody recorded. The store-maintenance pass now lifts a stray marker (one whose boundary commits all have their parents in the store) and names any other asskipped-shallow(the one-object-store maintainer contract in the repository's.claude/memory/contracts/); a repository that is really shallow is cured withgit fetch --unshallow.
The ready-to-merge push gate is OFF in this machine-wide bundle, on purpose. The bundle judges
every repo on the computer, so a gate baked ON would refuse every feature-branch push and
gh pr create in repos nobody opted into the ready-to-merge workflow. A session the app started
still gets that gate from its own per-session chain, where the user's setting applies. When the gate
is on, a push of a feature branch needs the branch's current SHA-bound ready-to-merge tag (the one
/ready-to-merge stamps after a real test run); a tagged push goes through, and an untagged push —
or one whose branch moved after it was tagged — is refused, unless the owner granted that push in
~/.claude/.push-approvals.json for that branch at that commit. The tag is read in the repo the
push actually runs in. The gate covers gh pr create as well as git push, and an approval
window or an excluded repo lifts both commands the same way. The protected branches are fixed
at master / main.
Developer guardrails vs. Git guardrails
| Git guardrails | Developer guardrails | |
|---|---|---|
| Scope | Sessions Omniscio spawns | Every Claude Code session Omniscio starts |
| Wiring | Per-session --settings at spawn |
The global ~/.claude/settings.json |
| Default | ON | OFF (opt-in) |
| Ready-tag push gate | Per-session (team default on) | Off in the bundle (see above) |
| Rule engine | git-guardrails.mjs |
Reuses git-guardrails.mjs |
What it adds over Git guardrails is reach, not rules. Git guardrails is handed to a session as Omniscio launches it, so a session started any other way never receives it. Developer guardrails sits in the global settings instead, so every Claude Code session the app starts is judged however it was started. What neither covers is a session Omniscio did not start: that one is allowed, except for the full-trust key print and the gcloud default-account switch.
Running both is harmless — on an Omniscio-spawned session they simply double-check the same rules (first to block wins).
One version, or no verdict
The check is a folder of about 40 modules, not one file, and each module is loaded defensively: one that fails to import drops to an allowing fallback so a half-written file can never wedge your sessions. That is the right trade for a broken file and the wrong one for a mixed folder — a single module from a different build can take a whole rule chain with it, and the guard then answers "allowed" to calls it refuses when whole, with nothing on screen to say so.
So the deployed folder carries a version stamp. When the guard installs its files it writes
guard-modules.buildstamp beside them: the fingerprint of every module it shipped plus one stamp
over the lot. The installer works that stamp out from the very files it is about to install, not
from a copy checked into the source folder, so a source folder whose own stamp is out of date still
installs a folder that agrees with itself; the self-test and the 15-minute check judge the installed
folder against the same rule. Before the guard answers anything — once per run, not once per tool call — it
recomputes those fingerprints and compares. If a module is missing, changed, unreadable, or the
stamp itself is gone, it refuses every tool call and says which module and which two versions
disagree. Refusing loudly is deliberate: an unprovable guard that answers "allowed" is worse than a
guard that says it cannot vouch for itself.
The practical effects:
- If you see
developer-guardrails REFUSED: guard-module-set-skew, the installed guard is a mix of two builds — usually an interrupted update, but also a synced master whose own stamp had not been refreshed yet. Turn the feature off and on in Settings → Features → Developer guardrails (or restart the app) and it reinstalls as one version. - Reinstalling is not a rollback trick: a complete older install still works, because it is internally consistent. What is refused is a mixture.
- Adding or editing a guard rule in a checkout means re-running the stamp step
and committing the stamp; do it again after
merging master into a branch that touched a guard module. Two branches that edited different
guard modules no longer conflict on the stamp: it merges with the settle-owned rule, and a land
that touched a guard folder rebuilds it before the base advances, never in a later pass.
Three things stand between a forgotten restamp and master: the
Guard-module set stampcheck in the merge gate's static lane (it runs on every branch — a diff naming no guard module no longer excuses it — and a red already on master cannot absorb it), the spec intests/unit/lint/17/guard-module-stamp-covers-the-deploy.test.ts, and the.husky/post-mergebackstop below. - The stamp covers exactly the modules the bundle deploy ships, which is the engine's
ENGINE_SIBLING_SCRIPTSplus the siblings it reaches in code. A module that merely lives in the engine folder is not in the bundle —staging-pathspec-table.mjsis inlined into thegitshim at build time and is never deployed — and naming it in the stamp is a skew refusal on every machine, because the deployed folder will never contain it. That is why restamping stamps the deploy's set and not the folder's contents. .husky/post-mergere-derives the stamp from the settled tree, through the sameamc_stage_regenhelper the generated doc indexes use: backup first, ceiling-bounded, staged only on a zero exit, and it can never fail a merge. It runs in the hook's regen-only pass — the unattended master sync, the road that settles local master — and only when that merge touched a guard module. It does not run for a hand merge in a linked worktree, which keeps relying on the branch gate and the spec; an auto-lander land settles the stamp itself.
Limits (v1)
- Protected branches are fixed at
master/main(not yet configurable, unlike Git guardrails). - It edits your global config, so it stays opt-in; a determined agent can still evade a shell-command rail (see "not a sandbox").
- Requires
nodeon PATH for the session's hook execution (the same assumption Git guardrails already ships with).
Related
Git guardrails is the per-session sibling: the same rules, wired into each session as Omniscio launches it. Developer guardrails puts them in your global settings instead, so they reach every Claude Code session the app starts however it was started.
One of these guardrails has a page of its own: Console window sentinel covers the rule that refuses a scheduled task which would pop a black console window, and the hidden-console helper that keeps automated work from stealing focus.
Plain Claude Code keeps native worktrees
Omniscio's native worktree refusal belongs to the private settings of sessions it starts, not the global Claude Code settings. On its next guard-manager check the app retires both old global hook formats while keeping unrelated hooks. Closing Omniscio no longer leaves that global worktree override behind after migration.
Enabled developer guardrails still refuse native worktree creation in managed sessions, including cloud sessions, and direct agents to the repository's required road. This computer uses patches rather than worktrees. Turning developer guardrails off omits that hook for newly launched sessions. Existing hook-free launch modes are unchanged. Already running sessions may need a new launch to load changed private settings.
Last verified 2026-10-23