Self-improving AI Employees for everyone
CI/CD Pipeline
Internal reference for OpenCompany's GitHub Actions setup. Workflow inventory, release flow, and the composite setup action.
The repo currently ships six workflows plus one composite action. Code scanning is live but has no workflow file: it runs through GitHub's default CodeQL setup, which is why alerts land in the Security tab with nothing in .github/workflows/ to point at (see Code scanning). The other hardening workflows described in earlier revisions of this doc (zizmor, rollback, reusable PyPI publish, cross-platform test-install) are not yet implemented — see Planned (not yet implemented) at the end.
Workflow inventory
+------------------+
push to main ----------> | ci.yml |---+
PR to main ------------> | | |
+------------------+ |
| +---------------------+
+--> | predeploy.yml |
| | (workflow_call) |
v*.*.* tag push -------> +------------------+ | | |
manual dispatch -------> | release.yml |---+ | - build-and-lint |
| | | - backend-tests |
| predeploy gate, | | - cli-tests |
| then publish | | - test-build-start |
+------------------+ | (3 OS) |
| +---------------------+
+-- publish-npm
+-- publish-github-packages
PR / push to main touching ------> +------------------+ terraform, image-signatures,
gateway/** or llm_defaults.json | gateway-ci.yml | dependencies, contract
+------------------+
Documentation is NOT deployed from this repo: the Mintlify docs live in the separate zeenie-ai/docs-OpenCompany repo and auto-deploy to docs.opencompany.sh via the Mintlify GitHub app (that repo's own workflow only runs
mintlify validate+ broken-links).
Workflow summary
| Workflow | File | Triggers | Purpose |
|---|---|---|---|
| CI | .github/workflows/ci.yml |
push/PR → main | Delegates to predeploy.yml |
| Predeploy | .github/workflows/predeploy.yml |
workflow_call |
build/lint + JS dependency audit + backend tests + CLI tests + cross-OS build/start smoke |
| Release | .github/workflows/release.yml |
v*.*.* tag, workflow_dispatch |
predeploy gate → publish (npm + GitHub Packages) |
| Desktop CI | .github/workflows/desktop-ci.yml |
PR touching desktop/** or the backend host-contract files; push to main touching desktop/** |
typecheck + unit + staged-tree invariants + electron-vite build + Playwright Electron smoke on ubuntu-22.04 (xvfb) and windows-latest |
| Desktop release | .github/workflows/desktop-release.yml |
v*.*.* tag, workflow_dispatch |
prepare drafts the GitHub Release from the annotated tag's message (first line = title, rest = notes); a 3-runner matrix (windows-latest x64, macos-15 arm64, ubuntu-22.04 x64) checks the synced version against the tag, builds installers with electron-builder and uploads into that one draft; finalize undrafts once every leg and the predeploy checks (the same reusable workflow release.yml runs) are green. Artifacts-only on dispatch unless publish is ticked |
| Gateway CI | .github/workflows/gateway-ci.yml |
PR / push to main touching gateway/**, server/config/llm_defaults.json or the workflow |
The LiteLLM gateway (LLM Gateway): terraform fmt/validate with Terraform 1.14.8, cosign verification of the pinned LiteLLM images, uv lock --check and pip-audit for gateway/uv.lock, then the contract and pin tests against the local mock stack. Path-filtered, so it is not a required check |
| Setup | .github/actions/setup/action.yml |
(composite) | bun 1.4 + Node 22 (CI-only: bun runs vite / vitest / eslint on it) + Python 3.12 + uv v8 + editable CLI install |
Toolchain pin
.python-version— single source of truth (3.12). The composite setup action currently hard-codespython-version: '3.12'insetup-pythonrather than reading the file viapython-version-file:; keep the two values in sync when bumping.
Required secrets
| Secret | Used by | Description |
|---|---|---|
NPM_TOKEN |
release.yml | npmjs publish access to the public @zeenie-ai scope (publish-npm) |
GITHUB_TOKEN |
release.yml, desktop-release.yml | GitHub Packages publish; desktop installer upload to the draft release and the finalize undraft (auto-provided; the desktop workflow needs contents: write) |
Desktop code signing is deliberately absent for the first releases: CSC_IDENTITY_AUTO_DISCOVERY=false is set so electron-builder never looks for a certificate. Adding it later is secrets-only (CSC_LINK + CSC_KEY_PASSWORD for Windows; a Developer ID cert plus APPLE_ID / APPLE_APP_SPECIFIC_PASSWORD / APPLE_TEAM_ID for macOS) plus the three mac flags in desktop/electron-builder.yml — see desktop_app.md.
Composite setup action
File: .github/actions/setup/action.yml
- uses: ./.github/actions/setup
- uses: ./.github/actions/setup
with:
node-version: '20' # override Node only; Python is fixed at 3.12
| Tool | Version source | Action |
|---|---|---|
| bun | oven-sh/setup-bun v2.2.0 — reads the root packageManager pin ([email protected]) |
Immutable commit SHA |
| Node.js | node-version input, default 22 — a CI-only convenience: bun runs vite / vitest / eslint on it via their node shebangs (open bun-runtime bugs in vitest and eslint); nothing shipped needs Node |
actions/setup-node v6.5.0, immutable commit SHA; package cache disabled |
| Python | hard-coded 3.12 (matches .python-version) |
actions/setup-python v7.0.0, immutable commit SHA |
| uv | astral-sh/setup-uv v8.1.0, cache disabled |
Immutable commit SHA |
setup-node's cache: is intentionally omitted — its post-job cache save fails with a Path Validation Error in lanes that didn't run a JS install (CLI / backend test jobs), which would mark the whole job red even when every test passed. No dependency cache is configured for bun either (unchanged from the pnpm era).
After tool install the composite installs the supervisor CLI editably (uv pip install --system -e .).
Predeploy validation
File: .github/workflows/predeploy.yml
Reusable workflow_call workflow with four independent jobs (no plan/change-detection gate, no aggregator — every job runs on every call):
build-and-lint—bun install --frozen-lockfile+bun run build, then client lint (bun run --filter react-flow-client lint), TypeScript check (... typecheck), frontend tests (... test, vitest), and the JS dependency audit (bun run audit:depsat the root and indesktop/; see "Dependency update policy" below). Runs onubuntu-latest.backend-tests— cross-OS matrix (ubuntu-latest,windows-latest,macos-latest,fail-fast: false; RFC-0005 Phase 1). On Linux only,uv lock --check(the committedserver/uv.lockmust matchpyproject.toml; the desktop app installs from it with--frozen) and a pinnedpip-auditcheck of the locked Python dependencies including all extras. Then, on every OS:- Pinned Temporal CLI. The app's own installer (
services.temporal._install.ensure_temporal_binaries) puts the CLI pinned inserver/config/temporal_cli.jsoninto a throwawayDATA_DIR, and the step writes its path to$GITHUB_ENVasTEMPORAL_TEST_CLI. The real-server tests that skip without it then run. - Full history. The checkout uses
fetch-depth: 0, because two replay testsgit showolder commits. - N-1 replay and identity gate. Before the full suite, a step checks that
TEMPORAL_TEST_CLIreports the pinned version (_install.binary_versions), then runstest_replay_corpus.py,test_workflow_identity_golden.pyandtest_run_graph_replay.py. The job setsTEMPORAL_REQUIRE_NATIVE_REPLAY=1(a missing CLI fails the gate instead of skipping it) andDEBUG=false. What the gate checks is in TEMPORAL_ARCHITECTURE.md -> The replay safety net. - Tests.
uv sync+uv run pytest tests/ -vinserver/, the whole suite, unsharded, undershell: bashon every OS. - Lock.
test_backend_tests_run_on_every_os_with_the_pinned_temporal_clilocks this.
- Pinned Temporal CLI. The app's own installer (
cli-tests—uv pip install --system pytest pytest-asyncio pyyaml+python -m pytest cli/tests/ -v. Runs onubuntu-latest.test-build-start— cross-OS matrix (ubuntu-latest,macos-latest,windows-latest,fail-fast: false). Runsbun run build, thenbun run tsc --version(proves the per-platform TypeScript 7 Go binary delivered viaoptionalDependenciesresolves on every OS — the type-check gate itself runs on ubuntu only;bun run, neverbunx, so it resolves strictly from the rootnode_modules/.bin), then a start smoke test. On Unix it backgroundsbun run start, readsPYTHON_BACKEND_PORTout of.env.templateand pollshttp://localhost:${APP_PORT}/health(curl -sf -m 5, every 2 s) for up to 90 s, giving up early if the start process exits. It always runsbun run stopafterwards, then fails unless/healthanswered. On Windows it starts the supervisor as a background job, waits 15 s, and fails if the job already exited.
Release workflow
File: .github/workflows/release.yml
Triggers
| Trigger | Behaviour |
|---|---|
Push of v*.*.* tag |
predeploy gate, then publish to npm + GitHub Packages |
workflow_dispatch |
Publish an existing tag again, to one or both registries (inputs tag, registries); the publish jobs check out that tag, the predeploy gate runs against the dispatching branch. Never cuts a new version |
The workflow default is contents: read. Publishing permissions are scoped to the job that needs them: the npmjs job needs nothing beyond contents: read (bun authenticates with the NPM_TOKEN it writes to ~/.npmrc; npm provenance attestation, and the id-token: write it needed, went away with the npm CLI), while GitHub Packages receives packages: write. Checkout credentials are not persisted in either publishing job.
Job graph
predeploy (uses predeploy.yml)
|
+-------------------+
v v
publish-npm publish-github-packages
| |
+- build +- build
+- cli version sync +- cli version sync
+- write ~/.npmrc + bun pm whoami +- write ~/.npmrc (scope route + token)
+- publish canonical package +- publish mirror package
@zeenie-ai/opencompany @zeenie-ai/opencompany
npmjs, bun publish --access public npm.pkg.github.com, bun publish
- Both publish jobs
needs: predeploy, run onubuntu-latest, and share the same prefix: immutableactions/checkoutwithpersist-credentials: false→ composite setup →bun install --frozen-lockfile→bun run build→python -m cli version sync. Neither job has asetup-nodestep of its own, but the composite setup installs Node (see the table above), which bun uses to run vite duringbun run build. There is no npm CLI anywhere in the release: bun packs, authenticates and publishes. publish-npm— writes//registry.npmjs.org/:_authToken=<NPM_TOKEN>to~/.npmrc, validates it withbun pm whoami, then publishes the canonical public npmjs package@zeenie-ai/opencompanyviabun publish --access public. npm provenance attestation was an npm-CLI feature and is gone with it.publish-github-packages— writes@zeenie-ai:registry=https://npm.pkg.github.com/and the//npm.pkg.github.com/:_authToken=<GITHUB_TOKEN>line to~/.npmrc, then a plainbun publish. bun 1.4 ignorespublishConfig.registry, and it keeps an.npmrctoken only for the registry that same file points at, so the route and the token must sit together; the v0.2.0 mirror publish went to npmjs with the GitHub token and failed withmissing authenticationbefore this was known (errors.md #24).bun publishruns the rootprepublishOnlyscript in both jobs, sopython -m cli version syncruns a second time inside the publish step (a no-op after the explicit sync step), followed by abun -echeck thatpackage.jsonstill hasbinandversion. The rootpublishConfigstill carriesregistry: https://registry.npmjs.orgbesideaccess: public(test_root_package_uses_public_zeenie_scopelocks both), but bun ignores thatregistrykey: each job's~/.npmrcalone decides where it publishes.
Both registries use @zeenie-ai/opencompany, matching the npm and GitHub
organization owned by the project.
There is currently no audit gate, no PyPI publish, no SLSA attest-build-provenance step, no GitHub Release step in release.yml itself (the desktop workflow drafts the release from the tag message), and no test-install stage — see Planned.
Cutting a release
The tag is the version. Everything else is derived from it, and there is no
CHANGELOG file: the annotated tag's message is the release notes (first line =
release title, the rest = body), which desktop-release.yml copies onto the
GitHub Release. Nothing publishes until a v*.*.* tag is pushed. A
workflow_dispatch run never cuts a version: it publishes an existing tag
again (inputs tag and registries), which is the retry path when a token
had lapsed or one registry failed.
Pre-flight.
maingreen on CI.NPM_TOKENunexpired: thebun pm whoamipreflight fails only the npmjs job, after the predeploy gate, while GitHub Packages and the installers still publish, so a lapsed token means a partial release (rotate the secret, then dispatch the Release workflow withtagset to the release andregistriesset to the registry that failed).bun publish --dry-run --access publicpacks cleanly from the checkout.Bump.
python -m cli version sync vX.Y.Zwrites the version into the root, client and desktoppackage.json,pyproject.tomlandcli/__init__.py(neverserver/pyproject.toml, whichserver/uv.lockrecords). Commit aschore(release): vX.Y.Z. This commit is load-bearing: the desktop workflow ships the committed desktop version and refuses to build when it differs from the tag, while the registry jobs re-runversion syncfrom the tag themselves.cli/tests/test_version.pyfails when the checked-in files disagree.The same commit carries the release's replay histories (RFC-0005 Phase 1), which the next release's replay gate replays. After
version sync, fromserver/, with the pinned CLI (installed byensure_temporal_binariesinto a throwawayDATA_DIR, never an installed one):TEMPORAL_TEST_CLI=<pinned temporal binary> uv run python -m tests.temporal.record_fixtures --source-commit HEAD. It records the code at the commit the bump sits on intoserver/tests/temporal/fixtures/X.Y.Z/and refuses to overwrite an existing set.test_the_current_version_has_its_replay_historiesincli/tests/test_release_pipeline_config.pyfails a version without one. Then the same command with--golden-onlyrewritesfixtures/workflow_identities.jsonfrom that commit, so the next cycle's identity checks compare against this release. Scenarios added between releases go into a supplementary folder. It is recorded from the previous release's commit, on that release's SDK (TEMPORAL_ARCHITECTURE.md -> The replay safety net). The release cut records every scenario, so its own folder holds them too.Tag.
git tag -a vX.Y.Z -F notes.mdon that commit, the notes in the shape of the previous tags (git tag -l --format='%(contents)' v0.1.0).Push the branch, then the tag. The tag starts
release.yml(predeploy gate, then npmjs + GitHub Packages) anddesktop-release.yml(draft with the notes, three installer legs and the predeploy checks, undraft once all pass) in parallel.Verify.
gh run watch; the registry'slatestdist-tag; the release page shows the notes with the installers and the threelatest*.ymlupdater feeds; on a clean machine the install script finishes throughcompany provision.
Semver in 0.x: a change that breaks the install or upgrade path bumps the
minor (0.1 -> 0.2), everything else the patch. There is no un-publish:
npm deprecate has no bun equivalent, so a bad release is followed by a
patch release. If a desktop leg or the desktop workflow's predeploy checks
fail, the release stays a draft holding the notes and the successful legs'
assets; re-run the failed jobs and finalize undrafts it.
Documentation deployment (separate repo)
The public Mintlify docs (docs.opencompany.sh) live in the separate
zeenie-ai/docs-OpenCompany
repo. Deployment happens automatically via the Mintlify GitHub app on
pushes to that repo's main; its own workflow only validates
(mintlify validate + broken-links). This repo previously carried a
docs.yml deploy workflow targeting an in-repo docs-OpenCompany/
folder — both the folder and the workflow are gone.
Source files
| File | Purpose |
|---|---|
.github/workflows/ci.yml |
CI entry point (delegates to predeploy.yml) |
.github/workflows/predeploy.yml |
Reusable validation (build/lint + JS dependency audit + backend tests + CLI tests + OS matrix build/start) |
.github/workflows/release.yml |
Tag / manual release: predeploy gate → publish npm + GitHub Packages |
.github/workflows/desktop-ci.yml |
Desktop shell checks on PRs: typecheck, unit, invariants, build, Playwright smoke |
.github/workflows/desktop-release.yml |
Tag-triggered desktop installers (NSIS / DMG+zip / AppImage+deb) into a draft release, then undraft. Separate from release.yml so npm publish is never blocked |
.github/workflows/gateway-ci.yml |
LiteLLM gateway checks: Terraform, image signatures, locked and audited test dependencies, contract and pin tests |
.github/actions/setup/action.yml |
Composite: bun + Node + Python + uv + editable CLI install |
.github/dependabot.yml |
Manual dependency updates — scheduled PRs suppressed; automatic security-update attempts also require the repository setting to be disabled; see below |
.python-version |
Toolchain pin (3.12) — single source of truth |
Code scanning
CodeQL runs through GitHub's default setup (Python + JS/TS), configured
in repository settings rather than by a workflow file. There is no
codeql.yml to read, so the only places the configuration is visible are
the Security tab and the CodeQL check on each push.
Triage has two outcomes, and picking the right one matters because the wrong one leaves a permanent lie in the code:
- Fix it when the call site can be restructured into a shape the query
recognises. For
py/path-injectionthat shape is normalise-then-prefix- check before the path is used: join,os.path.normpath, then refuse anything that does not start with the real base directory plus a separator.core/approot.py::resolve_static_assetis the worked example (alerts #158-160, September 2026). - Dismiss it when the flagged sink is the containment helper itself.
A guard placed after the
resolve()cannot clear the taint and an interproceduralfullmatchin a helper is not treated as a barrier, so the alert will return on every scan no matter what is written. Dismiss with a comment naming the containment invariant; do not add a decorative check that implies the alert was addressed.nodes/filesystem/_backend.py ::resolve_withinandnodes/_visuals.pyare the standing examples.
Two findings are dismissed as by-design rather than fixed:
| Query | Where | Why |
|---|---|---|
js/code-injection |
server/nodejs/src/index.ts /execute |
That route is the JavaScript executor behind the javascriptExecutor / typescriptExecutor nodes, so evaluating request-supplied code is its purpose. It binds to localhost and is spawned and called only by the same-machine backend; vm is documented as not a security boundary. |
py/path-injection |
containment helpers | See above. |
Inline // codeql[...] / # codeql[...] comments do not suppress
anything under default setup — several sat in the sidecar for months while
the alerts stayed open. Dismiss in the Security tab instead.
The Android port-forward endpoint addresses py/command-line-injection
(alert #167)
by passing a literal argv beginning with adb directly to subprocess.run
with shell=False. CodeQL's
subprocess model
can identify the fixed executable in an inline sequence; a separately assigned
argv variable can be treated as an entirely tainted command. FastAPI's
Query(pattern=...) is not a command-injection sanitizer in that model.
The handler also independently validates serials and integer port bounds before
starting ADB. See the Android contract
and security regressions.
Alert closure must be confirmed by a successful GitHub scan of the pushed fix;
local test results do not change an alert's server-side state.
Dependency update policy (Dependabot disabled)
The policy is no automatic pull requests, neither version bumps nor
security updates (since 2026-09-12). Every entry in .github/dependabot.yml
carries open-pull-requests-limit: 0 and ignore: dependency-name: "*".
This suppresses scheduled updates but does not disable GitHub's
alert-triggered security-update attempts. Enforce the policy with the
repository setting described below. Dependencies move by hand with tests:
- JS: bump the range in the relevant
package.json(or the top-leveloverridesblock in the root manifest for transitive pins),bun install,bun run audit:deps(at the root and indesktop/), run the suites. - pip:
uv lock --upgrade-package <name>inserver/,uv sync, run the suites (predeploy.ymlrunsuv lock --checkand the audit below). The gateway's test dependencies (gateway/uv.lock) move the same way, ingateway/;gateway-ci.ymlruns the same lock check and audit.
The Python gate exports exact pins from uv.lock without installing optional
extras. pip-audit==2.10.1 queries advisories with --strict --disable-pip --no-deps; it fails on vulnerabilities or packages it cannot audit. The export
is temporary and must not become a second committed dependency source. To run
the same gate locally from server/:
uv export --locked --all-extras --no-hashes --no-emit-project --output-file /tmp/opencompany-audit.txt
uvx --from pip-audit==2.10.1 pip-audit --strict --disable-pip --no-deps -r /tmp/opencompany-audit.txt
On Windows, use a file under $env:TEMP in both commands. Advisory lookup
requires network access; Python markers select the current platform, so the
Ubuntu CI audit also covers Linux-only dependencies.
The seven entries (bun /, bun /desktop, pip /server, uv /server,
pip /gateway, uv /gateway, github-actions /) declare the intended updaters; they do not guarantee
the ecosystem chosen for alert-triggered jobs. The
2026-10-06 Sharp update attempt
selected npm_and_yarn for /desktop, with no ignore conditions, despite
the existing Bun entry. It failed because that updater cannot modify
bun.lock. Do not add a second package-manager lockfile to work around it.
server/ retains both entries because its uv updater also needs the
manual-update policy; ignoring only pip previously allowed uv PRs.
Alerts themselves still appear in the repository's Security tab; they are
useful and cost nothing. Those for server/ come from uv.lock, which
Dependabot's "uv in /server" graph job resubmits whenever a push changes
it, so they close as fixed once the lock carries the fix.
server/requirements.txt is no longer committed; pip users export it on
demand (SETUP.md). As a tracked copy of the lock's pins it received every
Python alert twice, and GitHub matched it against a snapshot that only
Dependabot's pip graph job for the repository root refreshes, so those
copies never closed (the last 18 were dismissed on 2026-10-03). GitHub keeps
that snapshot until the job runs again (it last ran on 2026-09-12, for the
v0.2.0 release commit, which changed the root pyproject.toml); until then,
dismiss any alert filed against server/requirements.txt as inaccurate.
To stop automatic security-update attempts, a repository administrator
must disable Dependabot security updates under Settings > Code
security > Dependabot. Keep Dependabot alerts and the dependency
graph enabled. This stops automatic patch PR attempts while retaining
vulnerability detection and the CI audit gates. The equivalent command,
run with an administrator's GitHub CLI authentication, is:
gh api --method DELETE repos/zeenie-ai/OpenCompany/automated-security-fixes
This endpoint does not disable alerts. A YAML ignore rule cannot replace this setting, and updating dependencies does not change historical failed Actions runs. Fix current alerts, push the tested lockfiles, and verify the latest checks instead.
GitHub's dependency graph does not read bun.lock; it sees only the ranges
in each package.json, so no Dependabot alert ever covers a resolved JS
version. bun run audit:deps is the check: predeploy.yml runs it at the
root and in desktop/ (bun audit reads the lockfile). Both audits fail on
any advisory but one, ignored since 2026-11-02: GHSA-g3hv-75wg-m249,
minimatch's glob-pattern denial of service. It is fixed only in minimatch 11,
which no consumer accepts yet (eslint, @eslint/config-array and
typescript-estree pin 10.x; Electron Builder's chain needs 3.x to 10.x), and
it needs an attacker-supplied pattern, while every consumer is lint or build
tooling matching this repository's own patterns. Drop the --ignore from
both audit:deps scripts once eslint, typescript-eslint and Electron Builder
accept minimatch 11.0.1 or later.
The desktop chain Electron Builder → app-builder-lib → @electron/get 3.1.0
→ got → cacheable-request uses http-cache-semantics. To address
GHSA-ch52-4w7c-c8xp,
desktop/package.json pins the compatible 4.3.0 release and applies the
security backport through
Bun's standard patchedDependencies. The published 4.3.0 source still reproduces
the unsafe behavior, so the version floor alone is insufficient. The patch
requires validation before responses barred from reuse can be served through
max-stale, stale-while-revalidate or stale-if-error. Error fallback must also
match the URL, host, method and Vary headers. It preserves ordinary stale reuse,
private caches and the library's explicit public/immutable cookie opt-ins.
predeploy.yml runs a frozen desktop install with lifecycle scripts disabled,
then bun run test:security, before its desktop audit. The
security canaries use the
actual builder dependency chain, a fixed clock and fake credentials. They cover
unsafe reuse, serialized policies and compatible caching behavior; they failed
against unpatched 4.3.0 and pass with the backport. Desktop CI also runs them in
the full unit suite. All 128 official upstream tests at the published 4.3.0
commit passed before and after patching. A clean audit is paired with behavioral
checks because advisory version ranges cannot verify a local security patch.
The shadcn CLI was removed from client/package.json and the root lockfile on
2026-10-09, removing braces and its advisory entirely. The client used one
file from that package, its Tailwind stylesheet (shadcn/tailwind.css, the
Radix-state variants the generated components use), which is now a verbatim
copy at client/src/styles/shadcn.css. The existing
bun x shadcn@latest add <name> development command still works with the
checked-in generated components; it is not part of application execution.
Electron itself uses @electron/get 5.1.0, which uses native fetch. Stable
Electron Builder 26.17.0 (the v26 tag; latest remains 26.15.3) still requires
3.x. Do not force a 5.x transitive override: its removed GotDownloader API,
changed download options and proxy handling are incompatible with that caller.
The migration is in Electron Builder 27 prereleases. Keep the compatible
security backport until a tested stable upgrade fixes or removes this chain. See the
downloader migration notes.
When an upstream release fixes the behavior, update the version floor and remove the local patch only after the same security tests pass without it. A compatible parent upgrade that removes the package also resolves the advisory; validate desktop packaging before dropping its obsolete override and tests.
Re-enable updates deliberately, never by just deleting the ignore rules:
raise open-pull-requests-limit, add groups with patterns: ["*"] +
update-types: [minor, patch], and cooldown: {semver-major-days: 30}.
Planned (not yet implemented)
The following existed in earlier drafts of this doc but are not present in the current repo. Listed here so the intent is preserved without misrepresenting the shipped pipeline:
predeploy.ymlchange-detection + aggregator — aplanjob (dorny/paths-filter) gating downstream jobs, apre-commitjob, pytest sharding by domain, and aci-passedaggregator (re-actors/alls-green) as the single branch-protection target. Today every predeploy job runs unconditionally and there is no aggregator job.release.ymlhardening —workflow_dispatchdry-run default, a once-per-releasebuild-for-publishartifact,actions/attest-build-provenanceSLSA attestations, and acreate-github-releasejob for the registry publish (the desktop workflow'spreparejob now drafts the GitHub Release from the tag message;release.ymlitself still creates none). Dependency audits already run in the reusable predeploy workflow.publish-pypi.yml— reusable PyPI publish (OIDC trusted publishing,uv build --no-sources,pypa/gh-action-pypi-publish). No PyPI distribution is published today.test-install.yml— cross-platform end-user install smoke (bun add -g, git clone, install script) across 3 OS.rollback.yml— manual registry deprecate (npm deprecatehas no bun equivalent, so this would be the one place the npm CLI reappears) + optional revert PR.check-zizmor.yml— workflow-security linter (SARIF to the Security tab)..pre-commit-config.yaml— ruff / prettier / eslint / actionlint hooks (note: the project rule is to verify with pytest + the roottypecheckgate + eslint, not ruff). This file is not currently present in the tree; the entry describes intent, not a live hook.