Trust Center
Change Management Policy
How changes to code, infrastructure, and procedures are proposed, reviewed, and deployed.
This policy describes how changes — to application code, infrastructure configuration, third-party integrations, and operational procedures — are proposed, reviewed, deployed, and audited at SendTax.
It is a companion to our Information Security (§ 5.4, secure development), Access Control, Incident Response, and Business Continuity policies, and it documents the change-management procedures our Written Information Security Program relies on (§ 4.7).
Items marked Roadmap are not yet in production.
1. Principles
- Changes go through CI. A routine change to our code, or to the configuration kept in our repository, reaches production only through a release that passes automated checks, started from our main branch. The exceptions are named here, not implied: the automated version bump of our tax-rules engine (§ 5.1), a rollback to an earlier image, and the break-glass deploy (§ 10), each recorded as a privileged action. Nothing in our source-control plan blocks a merge (§ 5.4), so "only through CI" is a rule we follow and record, for the founders as for anyone.
- Two stages, every time. Production deploys are preceded by a staging deploy of the same commit. Staging is not a coincidence of trunk-based development; it is a deliberate gate. The break-glass deploy (§ 10.2) is the one exception.
- Reviewable history. Every change to code or configuration in our repository is traceable to a commit and an author, and every one but the automated version bump in § 5.1 to a pull request and its CI run. Changes made in providers' consoles are logged only when they are privileged actions (§ 8). The audit trail is the same surface engineers work in — not a separate ticket system that drifts from reality.
- Reversible by default. Every change should have a thought-out rollback. Database migrations are the special case (§ 9), but even then we deploy with the rollback in mind.
- Honest about scale. SendTax has one engineer. This policy describes the controls that are achievable at that scale, and says plainly where a control is a practice rather than a technical gate. It is not the formal-CAB process of a 200-person company.
2. Scope
This policy applies to:
- Application code — frontend (Next.js apps) and backend (FastAPI + Celery worker).
- Infrastructure as code —
fly.tomlfiles, GitHub Actions workflows, Dockerfiles, provisioning scripts underst-backend/infra/. - Database schema — Alembic migrations.
- Operational configuration — Fly.io secrets, third-party service configuration accessed through the relevant providers' consoles.
- Operational procedures — runbooks, internal documentation used in incident response and routine operations.
- Trust Center documents — these are themselves treated as changes that flow through the same review process.
It does not govern routine operator actions (a single deploy, a secret rotation) that are themselves applications of an existing documented procedure.
3. Change categories
Every change is one of four categories. Category drives the path it takes through this policy.
| Category | Definition | Path |
|---|---|---|
| Standard | Any planned change to code, infrastructure, or schema in the normal flow of work. | § 5 standard flow. |
| Pre-approved | Recurring routine changes documented as procedures (secret rotation, dependency updates, deploy to staging from an approved branch, the automated version bump of our tax-rules engine). | § 5 standard flow with abbreviated review; the engine's version bump is committed by its workflow (§ 5.1). |
| Emergency | A change required to contain or remediate an active incident, where waiting for the full standard flow would cause material harm. | § 10 emergency flow. |
| Trust Center / policy | A change to a Trust Center document or other published policy. | § 5 standard flow. Our policies and Trust Center documents are on the security surface (§ 6.3), so every change needs the Qualified Individual's approval, and each new version gets a row in the document's change history. |
4. Roles and responsibilities
| Role | Responsibility |
|---|---|
| Author | The person making the change, or directing the AI coding tool that drafts it. Responsible for the design, the implementation, the tests, and the rollout plan. |
| Reviewer | The person reading the change before it merges (§ 6.1). Not required for a change off the security surface; see § 6.2. |
| Qualified Individual (QI) | The person accountable for our security program under the WISP. Approves every change to the security surface before it merges, including every change to our policies and Trust Center documents (§ 6.3). |
| Deployer | The person triggering the production deploy. May be the author for standard changes. |
With one engineer, who is also the QI, the author, reviewer, QI and deployer are usually the same person. § 6.2 describes what stands in for a second reviewer.
5. The standard change flow
Every standard change moves through these stages. Our deploy workflows enforce the production path (§ 5.8); the stages before it are rules we follow, checked by GitHub Actions but not technically enforced (§ 5.4):
5.1 Branch and commit
- Work happens on a feature branch off
main, and changes reachmainthrough a pull request. Nothing technically blocks a direct commit (§ 5.4), so this is a rule we follow. The one exception is automated: when a new release of our tax-rules engine is published, a workflow (backend-bump-runner.yml) commits its version number and file checksums tomaindirectly, after checking that the release serves those files. That check proves the files weren't swapped after the release was built, not where they were built from: the release job can be started by hand from any branch, so a person with write access could cut a release from an unmerged branch and have it pinned onmain. Limiting that job tomainis on the roadmap. (Roadmap) - Commit messages describe what changed and why, not just what was touched.
5.2 Open a pull request
- Pull requests target
main. - The PR description states the user-facing intent, the testing approach, any operational risk, and the rollback plan if non-obvious.
5.3 Local checks before merge
The repository defines local pre-commit hooks for format and hygiene
checks, secret scanning (gitleaks), the fast lint and type checks CI
runs, API-client regeneration, and an end-to-end gate that names any
end-to-end suite that hasn't passed against the files being
committed. They are defined in
.pre-commit-config.yaml and the
frontend's st-apps/.husky/pre-commit.
In practice the hook installed on the engineer's machine is
advisory: it prints which local checks and end-to-end suites the
staged change calls for and never blocks a commit. The blocking
hooks run only on a machine where someone has installed them. Secret
scanning does not depend on them: since 2026-10-26 a CI job runs
gitleaks on every pull request and every push to main (§ 5.4);
GitHub's own secret scanning is still not turned on for our
repository. We run make check in the affected codebase before
merging, and the longer local suite (make qa-overnight) before a
release. (Roadmap: a blocking local gate.)
5.4 Continuous integration
Every PR triggers a lean set of CI checks. The backend and frontend
checks are scoped to the changed area by paths: filters; the
security-review checks run on every PR. Within that, a pull request
runs what its files can affect: a change to documentation only skips
the lint, type and build steps and runs the tests that read the
policies, and the training (CUDA) stack and the anonymizer engine's
tests are set up only when their code changes
(.github/scripts/ci_lanes.py).
The heavier checks
(integration tests, dependency audits, smoke E2E) run once a day in
the full run described in § 5.7, and again on the exact commit being
released (§ 5.8):
Backend (.github/workflows/backend-ci.yml):
tests—ruff(linter) andmypy(type checker), the lint and type checks ofmake check-fast, so skipping the local hooks (git commit --no-verify) doesn't skip them; the OpenAPI drift check; and the unit tests. The integration suite, which runs against PostgreSQL, andpip-auditrun in the daily full run.migration-gate— fails a PR that adds a destructive migration without an explicit acknowledgement.
Frontend (.github/workflows/frontend-ci.yml):
pnpm -w lintpnpm -w type(TypeScript type checking)pnpm -w build(full monorepo build)- Lockfile discipline — CI fails if
pnpm-lock.yamlis mutated unexpectedly during a CI run. - OpenAPI client drift check — the frontend's generated API client must match the backend's published OpenAPI schema.
- Monorepo test suite.
- Optional Playwright E2E suite, run when a PR carries the
e2elabel.
Every PR (.github/workflows/security-review.yml):
- A check that every rule defining the security surface (§ 6.3) still matches a file.
- A check that the automated security review (§ 6.3) of the current change is on the pull request, when the PR touches the security surface and isn't a draft. It doesn't apply to Dependabot's own pushes to its pull requests, or to pull requests from a fork.
Workflow changes (.github/workflows/action-pins.yml):
- A check that every action our workflows run is a release its own repository published. Each action is pinned by commit SHA, which can't be moved the way a version tag can; but GitHub also serves a commit that exists only in a fork under the original repository's name, so the check confirms, in the action's own repository, that the commit is the release its comment names.
Our GitHub plan does not offer branch protection, so a failing CI run does not technically block a merge. Merging only on green is the rule, and it is an operator practice rather than a technical control.
5.5 Review
Per § 6 below.
5.6 Merge
Merges to main use squash-merge by default for application code.
The merge commit message preserves the PR title and description.
5.7 Staging deploy
Once a day (05:00 UTC), if main has moved, daily-staging.yml runs
the full CI suite and, only if it passes:
backend-deploy.yml(staging environment) — builds and deploys tost-api-stgandst-worker-stg.frontend-deploy-web.yml(staging environment) — deploys the Fly-hosted frontend apps to their staging variants.- The staging end-to-end gate against the live staging apps.
Alembic migrations run as Fly's release_command before new
machines serve traffic; a migration failure aborts the deploy and
keeps the old machines healthy.
5.8 Production deploy
Production deploys are manual and go through one path. The
release.yml workflow ("Release to Production") is the single
sanctioned entry point for shipping a release. It first runs the full
CI suite (§ 5.4) on the exact commit being released, and nothing
deploys unless it passes. It then deploys that commit to staging,
runs the end-to-end suite against the staging apps, and only then
builds and deploys the same commit to production (backend-deploy.yml
and frontend-deploy-web.yml with environment: production). After
the deploy it runs a production smoke check. The deploy workflows can
be started by hand for staging only. Two documented procedures deploy
code to production outside release.yml: rolling back to an earlier
image (§ 11) and the break-glass deploy (§ 10.2). Each is recorded as
a privileged action
(Access Control Policy § 7). Secrets
(§ 8), database restores (§ 11) and machine scaling are applied to
production directly.
Inside the deploy workflow, a job gate enforces that no other
trigger (no workflow_run, no direct workflow_dispatch of the
deploy workflow) may set environment=production. This is a
real, code-level guarantee in
.github/workflows/backend-deploy.yml.
The deploy order is:
- Backend. Migrations apply first (via
release_command), then API and worker machines roll. Backend goes first because schema additions may be prerequisites for the new frontend. - Fly-hosted frontends.
st-filer-web,st-pro-web,st-admin-web. - Vercel-hosted marketing site. Fast-forwards the
deploybranch to the released SHA, which thest-wwwproject auto-deploys.
Each stage is rolled to staging and re-validated before its production counterpart proceeds.
6. Code review
6.1 What review covers
A reviewer is expected to read the change for:
- Correctness. Does the code do what the PR claims?
- Safety. Any risk to encryption boundaries, RLS, authentication, or audit-log integrity?
- Tests. Are there tests for the new behavior, and do they actually exercise the path?
- Operational fit. Migrations safe? Secrets handled correctly? Rate limits sensible? Errors logged?
- Trust Center alignment. Does the change require an update to any published policy or Sub-processors page?
6.2 Who reviews
SendTax has one engineer, who is also the Qualified Individual (QI) under our WISP. Much of the code is drafted with AI coding tools working under his direction, in sessions that open and merge pull requests under his GitHub account. In practice:
- Changes off the security surface merge on green CI. A change that doesn't touch the security surface (§ 6.3) merges once its CI checks pass (§ 5.4), with no human review required. This includes changes an AI coding session drafts, opens and merges without the engineer reading every line.
- Security-surface changes need the QI's approval before they merge, recorded on the pull request as § 6.3 describes.
- What stands in for a second reviewer. Every change except the automated one in § 5.1 goes through a pull request and CI (§ 5.4), the full suite runs before every staging deploy and every release, and pull requests that touch the security surface also get the automated security review in § 6.3 (except those Dependabot opens or that come from a fork). These checks catch a lot. They are not the same as an independent human reviewer, and we don't claim they are.
- Roadmap. A non-author human reviewer for security-surface changes (§ 6.3), and then for every non-emergency change, once there is a second engineer. (Roadmap.)
6.3 Sensitive-area reviews
The security surface is the code and configuration where a
defect could expose one customer's data to another, weaken
authentication or encryption, or let our automation weaken its own
checks. It is defined by a file in our repository
(.github/CODEOWNERS) and covers, among others:
- The encryption module
(
st-backend/app/core/encryption.py), document sealing and key management. - The Row-Level Security policies
(
st-backend/app/db/rls.sql), the tenancy module (st-backend/app/core/tenancy.py), the code that decides who a request acts for, the models that link firms, users and filers, and every database migration. - Authentication and MFA
(
st-backend/app/api/routes/auth.py, the identity-provider integration and its webhook handler, and the sign-in, sign-up and onboarding pages). - Audit-log writes (the
audit_service), rate limiting, and the scrubbing of logs and error reports. - Unauthenticated and third-party entry points, such as webhooks, inbound email, the pilot application form and cloud-folder connections.
- Training consent, download names and exports.
- The frontend's security headers and request proxies.
- Deploy workflows and
release_commandconfiguration (the backend'sfly*.tomlfiles), infrastructure scripts, and our CI workflows and review automation themselves. - Our policies and Trust Center documents, this one included.
A change that touches the security surface:
- Gets the automated security review: an AI model, prompted to
look for security flaws, reviews the changed surface files and
posts its findings on the pull request, each review as its own
comment. An AI coding session runs it before the pull request
leaves draft, and again when the surface files change; a check
(
.github/workflows/security-review.yml) fails until a review of the current change is on the pull request. It is one model's opinion, not an independent audit, and a red result blocks nothing by itself (§ 5.4). Pull requests opened by Dependabot or from a fork aren't held to it (for Dependabot, only its own pushes); there the QI's approval is the only review. - Needs the QI's approval before it merges. GitHub never lets a
pull request's author approve it, and the pull requests our AI
coding sessions open carry the QI's own account. So the approval
is recorded in one of two ways:
- On a pull request opened under the QI's account: his merge, or his explicit instruction to merge that pull request (by number, or as one of a set he names). A general instruction to ship a batch of work doesn't count. A session that merges on his instruction first records it on the pull request: who gave it, when, and which commit.
- On a pull request opened by anyone else, including Dependabot and a separate GitHub App account we plan to use for AI-drafted pull requests: the QI's Approve review on the pull request's latest commit.
- A commit added after the approval needs a new approval, unless it only fills in a policy version's approval date and approver, sets the same date in our compliance register, and regenerates its PDF.
- AI coding sessions never submit reviews. Because they run under the QI's account, this is a rule we follow and record, not a technical barrier.
GitHub enforces none of this on our plan (§ 5.4): it would let a pull request merge with a red check or without the approval. The approval is a recorded control, not a technical gate. A non-author human reviewer is Roadmap (§ 6.2).
7. Testing requirements
- Unit tests are expected for new application logic.
- Integration tests are required for changes touching the encryption module, RLS policies, audit-log hardening, and cross-tenant access paths. Existing integration tests cover these areas and a change is expected to extend rather than remove them.
- Migration tests — schema changes that affect existing data must include a backfill plan and, where feasible, a test that exercises the backfill against a representative dataset.
- End-to-end and manual checks. The end-to-end suite runs against the staging apps before every release reaches production (§ 5.8), and every release ends with a short manual check in production.
A change with failing CI does not merge (a rule we follow, § 5.4). Passing CI is enough for a change off the security surface; a security-surface change also needs the Qualified Individual's approval, which covers his judgment about its tests (§ 6.3).
8. Infrastructure and configuration changes
Infrastructure and configuration changes kept in our repository follow the same flow as code changes. Secrets and provider settings are changed outside it, as described below:
fly.tomlchanges go through pull requests. The backend's, which holdrelease_command, are on the security surface (§ 6.3).- GitHub Actions workflow changes are on the security surface
(§ 6.3). Backend CI's tests check the structure of the release and
deploy workflows, the frontend CI suite validates every workflow
file (
actionlint) when it runs, and a pull request that changes a workflow checks that each action it runs is pinned to a published release of that action (§ 5.4). - Secrets are set via
fly secrets setor via the provisioning scripts underst-backend/infra/, with the secret values themselves sourced from environment- scoped 1Password vaults. Changes to which secrets exist (the schema, not the values) flow through PRs. - Direct console changes to third-party providers (Cloudflare, Clerk, GCP, etc.) are minimized. A change to secrets, encryption settings or staff access is recorded as a privileged action (Access Control Policy § 7); other provider-side changes are not logged yet. (Roadmap: a change-log entry for each provider-side change.)
9. Database migration discipline
Database changes are the highest-risk category and have their own
runbook at
st-backend/docs/ops/MIGRATIONS.md.
The policy-level commitments are:
- Migrations are forward-only by default. We do not expect to
run
alembic downgradeagainst production. Recovery from a broken schema change uses PITR restore plus a corrective migration, not a downgrade. - Migrations run as Fly's
release_commandbefore new machines serve traffic. A non-zero exit aborts the deploy and keeps the old machines healthy. CREATE INDEX CONCURRENTLYand other non-transactional operations are called out in the pull request by their author, because they commit incrementally and partial state is possible on failure; a migration is on the security surface, so the Qualified Individual reviews it (§ 6.3).- Backfills of existing rows are written to be idempotent and run incrementally where the dataset is large.
- Dual-deploy pattern for breaking schema changes: deploy additive change → backfill → deploy code that uses the new shape → deploy cleanup of the old shape. The runbook describes this pattern in detail.
10. Emergency changes
An emergency change is one that must skip part of the standard flow because waiting would cause material harm — typically during an active Critical or High-severity incident (see Incident Response Policy).
10.1 What is permitted
During an emergency, the following may be relaxed:
- Pre-merge review. A security-surface code change may be merged without the Qualified Individual's prior approval (§ 6.3) if the Incident Commander authorizes it and is not the change's author. When only one person is available, the path narrows to a revert to a known-good commit or a deploy of a commit the Qualified Individual already approved. The authorization is recorded as a privileged action before the merge, citing the incident, and the Qualified Individual reviews the change afterwards. A policy version is never merged this way.
- Test coverage. A change may ship without tests for the new behavior if the corrective action is time-critical.
10.2 What is NOT permitted, even in an emergency
The following always apply:
- CI must pass. No emergency justifies merging code that fails lint, type checks, or existing tests.
- The staging → production sequence stands. An emergency
release through
release.ymlruns through the staging gate like any other; we do not skip it. release.ymlremains the path to production. Dispatching the deploy workflow straight to production is not permitted, and the workflow refuses it (§ 5.8). The one exception is the break-glass deploy: during a Critical or High-severity incident, if the engineer can't be reached or has delegated the deploy, and the release workflow can't be used, the other member of Howell & Gibbs LLC may deploy a commit that has already passed CI, following the documented procedure and recording it as a privileged action first (Business Continuity Plan §§ 5 and 6.10; Access Control Policy § 7). That deploy skips the staging gate. Its credentials have not yet been tested, so until they are, a fix may have to wait for the engineer.- Secrets are not committed to source control. Always.
10.3 After the emergency
Every emergency change generates a follow-up obligation:
- A post-emergency PR adds the missing tests, refines the hotfix into a clean change, and updates documentation as needed.
- The emergency itself is documented on the incident timeline per the Incident Response Policy.
- The post-incident review evaluates whether the emergency shortcut was justified and whether the standard flow needs adjustment to avoid the same shortcut next time.
11. Rollback
Every change must be rollback-able. Specifically:
- Application code rollback redeploys each app's previous
image, as the deploy runbook describes, recorded as a privileged
action (§ 5.8), or reverts the change and releases again through
release.yml. - Frontend rollback (Vercel) is performed by reverting the
deploybranch to the prior SHA and triggering an auto-deploy. - Schema rollback uses PITR restore plus a corrective forward-migration. We do not rely on Alembic downgrade scripts to rescue production.
- Configuration rollback uses
git reverton the relevantfly.tomlor workflow file, followed by a deploy.
The deploy runbook in
st-apps/docs/RUNBOOKS.md
documents the deploy and rollback procedures (see also the
Business Continuity Plan
§ 6.2).
12. Audit trail
The audit trail for changes is built into our tools, not maintained separately:
- Git history. Every change in our repository has an author, a timestamp, and a commit message, and every one but the § 5.1 version bump a PR reference.
- Pull-request history. Reviews, approvals, and comments are preserved by GitHub, including the record of the Qualified Individual's approval of each security-surface change (§ 6.3).
- CI history. Every check, every run, every failure is preserved in GitHub Actions for the duration of GitHub's default retention.
- Deploy history. Fly retains deploy records (image, who
triggered, outcome) and is queryable via
fly releases. - Application audit log. Sensitive actions inside the
running application are recorded in the
audit_logstable per the Access Control Policy § 8.
Together these provide a defensible record of who changed what, when, why, and with whose approval.
13. Documentation
A change is not complete until the relevant documentation is updated:
- Operational runbooks (
st-apps/docs/RUNBOOKS.md,st-backend/docs/ops/MIGRATIONS.md) are updated when a procedure changes. - CLAUDE.md is updated when the high-level architecture changes meaningfully.
- Trust Center documents are updated when a change affects any published commitment (sub-processors, security posture, data flows).
Documentation updates ride in the same PR as the change, not in a separate "follow-up" PR.
14. Periodic review
This policy is reviewed at least annually and additionally whenever:
- A real incident reveals a flow gap.
- A material change to our CI, deploy, or hosting architecture ships.
- The team size changes in a way that affects the review model in § 6.
Each version is recorded in the change history (§ 16) with the date the Qualified Individual approved it, and our Written Information Security Program § 14 sets out when a version takes effect. A review that changes nothing adds a row with the same version.
15. Contact
| Security disclosures | [email protected] |
| Change-management questions | [email protected] |
| General | [email protected] |
| Operating entity | Howell & Gibbs LLC |
16. Change history
| Version | Date | Author | Approved by | Changes |
|---|---|---|---|---|
| 1.0 | 2026-05-30 | Holly Gibbs | Not recorded | Initial publication (#101). Drafted with Claude. |
| 1.1 | 2026-09-24 | Liam Howell | Not recorded | Describes a one-engineer team and the checks as they run today (§§ 1, 4, 5.3, 5.4, 5.7, 6.2, 6.3) (#386). Drafted with Claude. |
| 1.4 | 2026-10-07 | Liam Howell | Liam Howell (QI), for Howell & Gibbs LLC | One version number and one change history for this policy's public text, its internal text (docs/policies/CODE_REVIEW_TIERS.md, code review and approval tiers) and its Notion page (WISP § 7.4). Until now they were kept separately: the internal text's change log had no version numbers, and its four rows are numbered 1.0–1.3 here; the public text was 1.0–1.1, and the Notion draft 1.0. Earlier rows are dated the day each version was merged (UTC): internal 1.0 had said 2026-06-14, 1.1 2026-06-16 and 1.3 2026-09-24; public 1.0 had said 2026-05-21 and 1.1 2026-10-01. Also records internal changes made without a row: #237 (2026-06-17, the recompute_jobs RLS gap closed) and #393 (2026-09-24, the dependency-scan gate). Header: Version, Effective date, Owner, Maintained by and Review cadence on both texts. Review cadence: at least annually (the Notion page and the compliance register said semi-annual). How changes are approved (internal § 2; public §§ 3, 4, 6.2, 6.3, 7, 10.1): a change to the security surface needs the Qualified Individual's approval before it merges, recorded on the pull request; other changes merge on green CI, including changes AI coding sessions draft and merge; GitHub enforces neither on our plan. The file that defines the security surface (internal § 3; public § 6.3) has no catch-all rule, and the surface now also covers our policies and Trust Center documents and three unauthenticated entry points it had missed. What runs where (internal § 2; public §§ 5.3, 5.4, 8): which checks run on each pull request and which only in the daily full run; the installed pre-commit hook is advisory, secret scanning runs only where its hook is installed (GitHub's own is not turned on), and the automated security review can't run on pull requests Dependabot opens or that come from a fork. Corrected in the public text: § 6.2 said the engineer reviews AI-drafted code before merge, but AI coding sessions have merged changes off the security surface without that; §§ 1, 5.1, 5.8, 10.2, 11 and 12 name the paths that reach main or production outside a pull request or release.yml (the rules-engine version bump, rollback to an earlier image, the break-glass deploy), and production is staged from the same commit, not the same image; § 10.2 the break-glass credentials have not been tested yet; § 5.3 the end-to-end gate was repaired on 2026-09-25; § 6.3 the automated review has covered the backend's fly*.toml files since 2026-09-24; § 7 the only manual release check runs in production, after the deploy; § 8 provider-console changes are logged only when they are privileged actions; § 12 the table is audit_logs. Public §§ 5.8 and 11: a rollback to an earlier image, like the break-glass deploy, is recorded as a privileged action. Public § 15: change-management questions go to [email protected]. Internal § 6: the branch-protection script would require only the checks that run on every pull request. Repository links fixed. Drafted with Claude. |
| 1.5 | 2026-10-07 | Liam Howell | Liam Howell (QI), for Howell & Gibbs LLC | Internal § 5 item 4: no independent security review or penetration test of the RLS, encryption and auth core has been done, and none is scheduled; we will commission one when a client's requirements call for it (it recommended one at least annually). This change applies from the day this version is published on send.tax. Drafted with Claude. |
| 1.6 | 2026-10-08 | Liam Howell | Liam Howell (QI), for Howell & Gibbs LLC | Public § 5.4 and internal § 5: a pull request's CI runs what its files can affect (.github/scripts/ci_lanes.py, #504): a change to documentation only skips the lint, type and build steps and runs the tests that read the policies, and the training (CUDA) stack and the anonymizer engine's tests are set up only when their code changes; the daily full run and the release still run everything. Public §§ 5.4 and 6.3, internal §§ 2, 5 and 6: the automated security review waits for a draft to be marked ready, runs once per change to the security-surface files (a push that leaves them as they were keeps the earlier, signed result; a re-run reviews again), reads each changed file in full and the settled decisions (.github/security-review-decisions.md, from the base branch; a pull request that also changes the review's workflow or script runs its own version, which the QI reviews by hand), splits a large change instead of truncating it, and keeps each review as its own comment; the reviewer is Claude Opus 5.5, and internal § 5 says why not a different model. Drafted with Claude. |
| 1.8 | 2026-10-09 | Liam Howell | Liam Howell (QI), for Howell & Gibbs LLC | Public §§ 5.4 and 6.3, internal §§ 2, 5 and 6: the automated security review runs in an AI coding session on the QI's Claude subscription before a pull request leaves draft, not in CI on each push, and the check on each pull request (.github/workflows/security-review.yml) calls no model: it fails until a review of the current change is on the pull request. On 2026-10-08 the review in CI had cost about $7 in a day. The review reads 40 lines of code around each change, and a changed file in full only when it is under 15,000 characters. The reviewer stays Claude Opus 5.5 at effort high: replaying nine past pull requests with known findings, Claude Sonnet 5.5 found 3 of the 8 known real issues and Opus 5.5 found 7, and effort medium missed the subtlest for 14% less. Drafted with Claude. |
| 1.9 | 2026-10-09 | Liam Howell | Liam Howell (QI), for Howell & Gibbs LLC | Public §§ 5.4 and 8, internal § 2: a check on each pull request that changes a workflow, an action.yml or the check itself (.github/workflows/action-pins.yml, .github/scripts/check_action_pins.py) confirms that every action our workflows run is pinned by commit SHA to the release its comment names, in the action's own repository. GitHub also serves a commit that exists only in a fork under the original repository's name (an impostor commit), and neither a reviewer nor the automated security review can tell one from its SHA, so the check asks git, and a pin that isn't such a release fails it. Backend CI's tests check, without the network, that every action is pinned by SHA with its release in a comment. Three actions our workflows still named by version tag (actions/setup-node, actions/setup-python, actions/create-github-app-token) are now pinned by SHA. The security review's settled decision on action versions (.github/security-review-decisions.md, decision 8) now leaves checking pins to this check. Drafted with Claude as 1.7, and renumbered when 1.8 was approved first, so there is no 1.7. |
| 1.10 | 2026-10-09 | Liam Howell | Liam Howell (QI), for Howell & Gibbs LLC | Internal §§ 2 and 5, public §§ 5.4 and 6.3, settled decision 9: the AI security review may run on either member's Claude subscription. The check counts a review posted by the QI on any pull request, and one posted by the other member only on a pull request she opened; both lists of logins live in the check's workflow file rather than a repository variable. Both members keep model training off in their Claude accounts and two-factor authentication on GitHub, and the quarterly access review confirms both. Who approves a Tier-1 change is unchanged: the QI. The Dependabot exemption is worded as the check applies it (only Dependabot's own pushes). Drafted with Claude. |
| 1.11 | 2026-10-26 | Liam Howell | Liam Howell (QI), for Howell & Gibbs LLC | The 2026-10-26 security and legal review. Internal § 2 (public § 5.4): secret scanning runs in CI on every pull request and push to main (gitleaks, pinned and checksum-verified, .github/workflows/secret-scan.yml), with a narrow allowlist (it exempted every test folder, the policies and the infra scripts by path); production deploys run only from main (the release and deploy workflows refuse any other ref; a dispatch from any branch could ship before). Public § 1 corrected: "no change reaches production without passing automated checks; there is no trusted bypass" named none of the three paths the same policy documents (the rules-engine bump, a rollback, the break-glass deploy); it now names them. Public § 5.1 corrected: the rules-engine release job can be started from any branch, so the bump could pin an unmerged build on main (the internal text said so; the public text didn't). Public § 8 corrected: a non-transactional migration is called out by its author and reviewed by the Qualified Individual, not "flagged in code review", which off the surface doesn't exist. Public § 10.1 and internal § 2: an emergency merge of a security-surface code change is authorized by someone other than its author (a revert or a deploy of an already-approved commit when only one person is available), recorded as a privileged action citing the incident, reviewed by the Qualified Individual afterwards, and never covers a policy version (the internal text had no emergency path). Drafted with Claude. |