feat(identity): reload the identity map without a server restart - #280
Merged
Conversation
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 1, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 1, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 1, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
omegent-app Bot
pushed a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 2, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 3, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 3, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 3, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 3, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 3, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 3, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 3, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 3, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 4, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
patroza
added a commit
that referenced
this pull request
Aug 4, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 4, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 4, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 4, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 4, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 4, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 4, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 4, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 4, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 4, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 4, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 4, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 4, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
patroza
added a commit
that referenced
this pull request
Aug 5, 2026
The server read T3_IDENTITY_MAP_PATH once at layer construction, so adding or removing a person meant restarting t3code-server. The map is now re-checked on a 60s TTL and applies in place. Polls rather than watches: the map arrives over virtiofs from the host, where inotify propagation is not something to depend on. An ino/size/mtime fingerprint keeps an untouched file from being re-parsed every TTL. Two safety rules, because a reload can now fail in production where startup could not: - A re-read that yields no people never disables an already-enabled map. `enabled === false` turns the operate gate off entirely, so a truncated or unparseable file would have failed open. The last good map keeps serving, marked unhealthy, and the next TTL retries. - requireOperateClaim no longer deletes the persisted claim of a person who is absent from the map. A half-written file can still parse as a valid map with a subset of people, and that delete is not reversible. Refusing operate is the gate; membership is re-checked on every operate, so a stale row grants nothing. Startup behaviour is unchanged: a missing or empty map still means the feature is off, and removing T3_IDENTITY_MAP_PATH remains the way to disable the gate. Co-authored-by: T3 Code PR Stack <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> (cherry picked from commit 3b2203f)
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Problem
IdentityServicereadT3_IDENTITY_MAP_PATHonce at layer construction and capturedpeoplein a closure. Adding or removing someone required restartingt3code-server.Change
The map is re-checked on a 60s TTL (
IDENTITY_MAP_RELOAD_TTL_MS) and applies in place.Every read path (
getSnapshot,listMapPeople,claim,requireOperateClaim,resolveByJiraAccountId,isMapEnabled) now resolves a snapshot instead of a captured list.Polls rather than watches: the map arrives over virtiofs from the host, where inotify
propagation isn't something to depend on. An
ino:size:mtimefingerprint avoidsre-parsing an untouched file each TTL. Time goes through
Clock, so the TTL is testable.Safety
Reload can now fail in production where startup could not, so two rules:
A re-read yielding no people never disables an enabled map.
enabled === falseturns the operate gate off entirely — a truncated or unparseable file would have
failed open. The last good map keeps serving, marked
healthy: false, and the nextTTL retries (the fingerprint is deliberately not advanced).
requireOperateClaimno longer deletes the claim of an absent person. UnderlayerPersistedthat eviction is adeleteBySessionId— irreversible. A half-writtenfile can parse as a valid map with a subset of people, so rule 1 alone doesn't cover
it. Refusing operate is the gate; membership is re-checked on every operate, so a stale
row grants nothing. This is a deliberate behaviour change.
Startup behaviour is unchanged: missing/empty map → feature off, and removing
T3_IDENTITY_MAP_PATHis still how you disable the gate.Tests
New
IdentityService.reload.test.ts, driving real files withTestClock:enabled, reportshealthy: false, and recoversGates:
typecheck,lint(exit 0),fmt:check, fulltest— 2118 passed / 11 skipped.Companion
Host-side staging (
installinstage-secrets.sh, ops repo) truncates and rewrites inplace, and the guest reads that inode live. Nothing observed it mid-write before; a
reloading server does. An atomic temp+rename there is the other half of this — separate PR.
Targets the
fork/identityoverlay (PR #250) per AGENTS.md.🤖 Generated with Claude Code