Skip to content

armgit / mso

Public Imported from GitHub
0

Browser-based graphical shell and control plane for a Linux server you own — real terminal, file manager, live metrics and BYOK AI in one mobile-first workspace. Next.js 16 · React 19 · node-pty · Tailwind v4 · shadcn/ui. Public alpha, self-hosted.

merge(ci): integrate isolated verification runner

Rahman8c2c1f0f27ff
diff --cc .env.example
index 7e732cbc,e71d3b21..01662681
--- a/.env.example
+++ b/.env.example
@@@ -419,18 -359,7 +419,22 @@@ OS_MCP_MAX_SCOPE=exe
# Leave unset to use the owner's ~/.local/bin/sc. No credentials belong here.
# MSO_SC_BIN=/absolute/path/to/sc
+# --- Hosted passive security scan (GitHub Actions, not application configuration) ---
+# Set MSO_DAST_URL as a repository Actions variable to the approved HTTPS instance.
+# Actions does not read this .env.local file. The standalone target-check command
+# also accepts the value from its environment. No credentials, query or fragment.
+# MSO_DAST_URL=https://mso.example.com
+
+
+# --- Batonly capability federation (optional) ---
+# Start the Batonly pull worker only when this MSO installation has a project
+# containing an MCP server alias named "baton". The project hint defaults to "baton".
+# Override only when the local project is registered under another exact name/path/id.
+# MSO_BATONLY_FEDERATION_PROJECT=baton
+# Emergency/instance opt-out. Set 1 to keep the federation worker disabled even when
+# the Baton project MCP is configured. Batonly never receives an MSO bearer credential.
+# MSO_BATONLY_FEDERATION_DISABLED=0
+ # Optional XDG state base for the manual independent CI runner. Defaults to
+ # $HOME/.local/state; the runner appends mso-ci and enforces owner-private access.
+ # Set in the invoking shell; the CI CLI does not load .env files or credentials.
+ # XDG_STATE_HOME=/absolute/owner-private/state-base
diff --cc docs/PROGRESS.md
index 9e6119c7,87b411f8..28c238a5
--- a/docs/PROGRESS.md
+++ b/docs/PROGRESS.md
@@@ -1,669 -1,11 +1,675 @@@
+## 2026-09-29 — Provider-neutral A2A workflow trace skill
+
+Added the official `a2a` skill and `mso a2a trace` bridge so external AI CLIs can keep one owner-authenticated durable MSO session/workflow while they work. The bridge records only concise plan/progress/action/evidence/blocker/result/handoff summaries, correlates every milestone with the exact workflow id, exposes semantic context for later agents, and preserves MSO workflow isolation and Evidence Receipt gates. It explicitly rejects private chain-of-thought as a trace surface. Local run metadata is stored under the owner-private MSO state directory; remote A2A trust boundaries and cross-device session ownership remain unchanged.
+
+## 2026-09-28 — Bounded MANEF application catalog
+
+Added a versioned metadata catalog to manef-web and an Owner-only MSO reader. The site PR merged, but Vercel blocked its production deployment; live publication remains pending hosting access. The remote list may order existing reviewed Managed App adapters or offer a portable connection template; it cannot authorize a new installer, command, URL, credential or grant. Selecting a managed entry follows its existing preflight and setup; selecting a connected entry still requires an instance address and explicit Owner review. The server pins the catalog URL, bounds and validates the whole response, caches a valid copy for a short outage and leaves local installers available without the site. This completes remote discovery for this profile while generic installation recipes, domains and independent package releases remain separate work.
+## 2026-09-28 — Native host and shared relay groundwork
+
+A separate design contract maps the supplied Remote Desktop Commander actions onto MSO capabilities and defines the account, device, OAuth, scope, pairing, revocation and outbound connection boundaries for a shared mso.manef.dev/dashboard and /mcp service. The shared relay is not implemented or deployed; the hostname is not yet resolving.
+
+The host runtime now selects PowerShell for Windows PTYs, samples CPU on non-Linux systems, reads macOS/Windows process inventories, and parses OS-specific file-root delimiters. Candidate native Mac/Windows installer and foreground launcher build MSO with Node, Bun and node-pty in the host account and bind loopback; CI checks a fresh build and health route on both OS runner families. These candidates are not connected to the public installers. Physical-machine login, device approval, PTY, filesystem containment, update, service lifetime and remote MCP remain release gates. The public macOS Lima and Windows WSL2 paths remain the current installed release.
+
+## 2026-09-28 — Portable connected app manifests
+
+Added a bounded connected-app manifest profile and Store file/paste → review → connect journey. Portable publisher/version/presentation metadata stays separate from per-instance IDs and endpoints; one definition can connect several instances. The shared validator rejects unsupported fields/versions and executable payloads in both client and server. Import uses existing Owner authority, revision locking, cookie isolation and atomic registry storage. Connection edits preserve the original manifest and disconnect never touches service data. The starter JSON and current contract document what works; the full feature loader, verified remote manef.dev catalog and generic installers remain pending. No dependency on unrelated manef-ui/manef-db is introduced.
+
+The full coverage gate exposed an existing count-cap continuation test racing the independent four-second scan budget under load. Count-cap fixtures now use a controlled clock; an additional deterministic deadline case verifies that timed-out scans resume without losing or duplicating projects. Production scan limits and assertions remain unchanged.
+
+## 2026-09-27 — External feature contract and registry audit
+
+## 2026-09-27 — Readable Settings action labels
+
+PR95 CI exposed default Settings action labels at 4.13:1 against dark cards (and 4.0:1 on hover), below the required 4.5:1. Default action labels now use the same foreground token as other settings rows; icons retain the info tint and destructive labels retain their semantic color. The existing real-browser backup accessibility journey remains the release gate, without exclusions or reduced assertions.
+
+
+## 2026-09-27 — Server-persisted connected applications
+
+The Owner App Store now exposes real Managed Apps setup and a versioned external connection registry. Connected tools run separately and become dynamic shell windows without rebuilding MSO. Registry mutations share the surface-store lock and revision, reject cross-placement ownership and cookie-scope overlap, and never execute install scripts or delete service data. HTTP/no-domain connections open separately; n8n and registered tools share the reviewed iframe renderer. Legacy HTML manifests require registry admission. manef-ui and manef-db are unrelated and excluded. Remote catalog delivery and extraction of native features remain pending; see CONNECTED-APPS.md for the implemented boundary.
+
+
+Defined the v1 design contract for portable feature definitions, separate installation
+bindings and grants, embedded views, reviewed adapters, shell slots and lifecycle
+verification. Audited the existing AppShell, runtime App Store, SurfaceApp and Managed
+App registries against baseline 330d0cb4, with twelve findings and ordered migration
+gates. This documentation does not implement a dynamic plugin loader or broaden
+existing execution/embed permissions. The documentation map explicitly separates
+the proposed contract from current runtime references.
+
+## 2026-09-27 — Managed app host compatibility preflight
+
+Managed app definitions now declare the installer backends they actually support:
+Hermes user systemd or Docker, OpenClaw user systemd, and 9Router Docker.
+The install API checks the local Linux runtime and reachable backend before
+starting a job or downloading an artifact. This includes Android tablets hosting
+MSO under Ubuntu PRoot: MSO core can run there while applications whose runtime
+backend is unavailable are rejected with a specific reason. The 9Router
+not-installed diagnostic no longer mislabels an accessible Docker host as
+uncertain solely because its user systemd bus is absent.
+
+The Managed Apps documentation matches the reviewed Hermes Docker fallback.
+This step does not add a Docker daemon to Android PRoot or claim those three
+applications can all run on every tablet. Physical host verification remains open.
+
+## 2026-09-27 — Portable host installer safety
+
+An Android tablet with supported arm64/x86_64 architecture can host the MSO Linux
+runtime inside Termux/Ubuntu PRoot; the tablet does not require a second VPS.
+The adapter now rejects unsupported CPU architectures before package downloads.
+On rerun, the canonical core installer rejects a checkout whose current commit
+is not an ancestor of the fetched target. The Termux adapter only reattaches
+`main` when its old tip is an ancestor of the installed tip, avoiding the old
+forced branch reset over local commits. Both installer digest pins advance with
+the changed payloads. The Windows bootstrap now verifies the chosen distro is
+WSL2 before installing; when several distros exist without Ubuntu it asks for
+an explicit choice instead of taking the first list entry.
+
+Focused installer/platform/docs tests passed 39/39 plus TypeScript and shell syntax
+checks in an isolated worktree. A physical Android tablet and Windows/WSL2 host
+still need fresh-install, process-background, remote-access, update and recovery
+acceptance before those platforms can be claimed verified. This increment does
+not implement the managed app manifest, domain/IP provisioning or multi-host
+registry from the broader agnostic audit.
+
+## 2026-09-27 — JEV decision plane and value capsules
+
+JEV is now a versioned bounded decision plane rather than a Workflow-only adapter.
+Decision definitions, bounded state compilation, action proposal/execution separation,
+post-action semantic verification, memory admission, model/context/failure routing and
+metadata-only telemetry share one policy surface. JEV action proposals are held
+server-side, expire, bind the exact capability contract digest and can auto-execute only
+safe non-destructive reads through the existing MSO Capability Runtime; write/review/
+destructive candidates remain on the normal explicit tool path.
+
+Session preservation advances from a thin receipt to an exact-source
+`mso.jev-session-capsule.v1`. Every capsule is bound to the current session SHA-256 and
+byte count and retains bounded semantic steps, tool routes, artifact references, decision
+metadata and the LLM continuation packet. `agent_session_resume` automatically includes
+that capsule while the source identity still matches, so zero-recommendation sessions
+still have useful continuation value. Capsule existence remains preservation/value
+evidence and does not authorize deletion of raw session evidence.
+
+Integrations → AI Providers exposes JEV connection state, actual provider-reported usage
+separately from estimated avoided LLM impact, calibration/decision metadata, preservation
+coverage and an owner-only bounded JEV Lab. Workflow Sessions explicitly distinguish JEV
+DECISION, MCP ACTION and VERIFIED RESULT and show the continuation capsule value summary.
+
+The public MCP action contract advances to toolset `2026.09.27.1`. External clients that
+cache MCP descriptors must refresh or rescan actions before using the revised `jev_action`
+schema and read scope.
+
+## 2026-09-27 — Windows taskbar fidelity release
+
+The Windows desktop shell taskbar now follows the supplied Windows 11 reference
+instead of using generic dashboard-like chrome. It keeps the native 48px taskbar
+geometry, centers Start/search/apps, uses a 34px rounded search pill, keeps running
+windows as compact icon buttons, and moves VPS connection status into a
+Windows-style tray affordance. The trailing tray now presents locale,
+Wi-Fi/volume/battery, clock/date, and the thin Show Desktop target without changing
+the underlying shared window/control-center/status behavior. Browser locale selects
+the visible Search/Pencarian and ENG/IND labels; the shell remains portable rather
+than hardcoding one operator locale.
+
+PR #89 merged the taskbar implementation into main as 662e4179. Release validation
+is performed against exact merged main, not only the feature branch. The first
+exact-main full gate correctly found the Tool Forge fixture image absent on this
+host; the repository's explicit offline provisioning script restored that required
+test dependency. A later full-suite PTY timeout was isolated as environmental after
+the exact test passed twice standalone. Deployment remains gated on a clean complete
+release-gate run plus exact-SHA runtime/health/chunk/browser proof.
+## 2026-09-27 — Settings version, updates, and optional breadcrumbs
+
+Account still owns the profile, password, Devices, and the About overview.
+Version and software updates are nested pages under About, so `?section=about`
+stays the overview and `?section=about&page=version` (or `updates`) opens the
+detail. Version reads `/api/health` — the same build id, build SHA, and app
+version the watchdog already reports — and falls back to that same baked-in
+identity when the probe does not answer. Updates still calls the existing
+self-update API.
+
+Nested Settings pages opt into a trail with `SettingsFeatureCell`'s optional
+`breadcrumbs` prop. Omitting it renders the cell's children with no extra
+chrome. MCP's inbound pages use that same prop instead of a one-off back row.
+
+## 2026-09-26 — Settings Account section
+
+Settings now opens on an Account section. Rename, icon, and password reset live
+there, and Devices and About are reached from inside Account instead of as
+sibling sections. The display name and icon are the owner profile in
+`~/.mso/account.json`. The file stores a display name copied from validated
+code units and a raster icon re-encoded from magic-checked bytes, with mode
+0600 and an atomic rename. Password reset still rotates `OS_LOGIN_PASSWORD` in
+`.env.local` with the existing constant-time compare; it does not add a second
+password store. Deep links to `?section=devices` and `?section=about` still open
+those panels, and mobile back returns to Account.
+## 2026-09-26 — Crash-safe continuation and source-isolated agent work
+
+ChatGPT/MCP continuation no longer depends on the user recovering a dead tab or
+manually finding a durable session id. `agent_session_resume` can auto-select the
+newest relevant unfinished workflow/session by stable principal and project, return
+safe recent context plus a fresh `workflow_start` recipe, and return human session
+candidates rather than guessing when multiple unfinished tasks are plausible. Old
+workflow ids remain conversation-scoped and are never reused across sessions.
+
+Source-changing workflows now prepare a task-owned linked Git worktree after
+read-only discovery succeeds. Workflow-bound filesystem/project/shell mutations are
+restricted to that workspace; a dirty canonical checkout fails closed instead of
+being stashed, reset, or overwritten. Clean unused task worktrees may be removed
+only by their own workflow close path; changed work is preserved.
+
+The release reconciliation keeps both JEV session optimization and the new Workflow
+learning/second-brain surfaces. JEV archive receipts remain checksum-bound
+preservation evidence, but they are not deletion authority: fail-closed session
+preservation keeps raw archives until a separate explicit source-release policy
+exists. This supersedes the earlier same-day wording that a JEV receipt alone could
+authorize aged archive deletion.
+
+Conflict-focused regression coverage passed 35/35 plus TypeScript and targeted
+zero-warning ESLint before the full release gate. Full build/runtime evidence remains
+a separate release-stage requirement and is not implied by this entry.
+
+## 2026-09-26 — JEV session preservation + OpenRouter SSOT
+
+JEV now uses `~typesafe/jev-latest` through OpenRouter’s Decisions API by default. Its credential is read from the same `hostCredentialStore()` used by Settings → AI and Integrations → AI Providers, so MSO no longer needs a separate TypeSafe/JEV token for the normal path. Existing named MCP JEV connections and the `JEV` Integration Variable remain explicit diagnostic compatibility overrides. Workflow Sessions expose **Use JEV**, can copy a bounded `mso.jev-session-optimization.v1` packet for another LLM, and expose **Optimize all before cleanup**. Batch preservation covers both live durable sessions and archived compacted session snapshots. Old archive deletion is hard-gated by an exact SHA-256-bound JEV preservation receipt; unpreserved archives and their action indexes are retained instead of silently aging out.
+
+## 2026-09-26 — Make DOKU credential fields self-explanatory
+
+The native DOKU setup form now puts the official source beside each credential
+label instead of forcing the operator to interpret one generic help panel. Payment
+Client ID and Payment Secret Key link directly to the Sandbox and Production API
+Key surfaces; Payment Environment links to the environment guide and Sandbox
+registration. Safe, clearly synthetic placeholders show the expected shape without
+resembling a stored credential.
+
+Payment Environment is now explicit product language rather than an implied DOKU
+secret: it is the operator choice `sandbox` when the Client ID + Secret Key come
+from DOKU Sandbox/testing, or `production` when they come from the live DOKU
+Dashboard. The REST Secret Key remains distinct from the DOKU MCP API Key.
+
+The form renderer gains reusable per-field HTTPS reference links, so the same
+pattern can be applied to other integrations without duplicating provider-specific
+markup. Secret storage, masking, verification, and blank-to-keep behavior are
+unchanged.
+
+Verification: DOKU/setup regressions pass 23/23; TypeScript and zero-warning
+focused ESLint pass; the isolated Next.js production build, bundle budget,
+mandatory release E2E, native Integrations responsive shell journey, native Google
+Integrations regression, shell status checks, and deferred shell-performance gates
+all pass.
+
+## 2026-09-26 — Backup history and checksum-bound verification records
+
+Extended the existing owner-only server-memory backup, without creating another
+backup authority. Settings and CLI can page saved metadata, select an old snapshot
+for an explicit isolated restore check, distinguish partial coverage from recorded
+integrity, and show unreadable/error states instead of false empty or complete
+results. Manifest coverage totals are validated by one shared reader. Successful
+rehearsals retain an immutable checksum-bound receipt; old snapshots may lack one.
+
+Targeted synthetic manifest/history/receipt/API/CLI/transport tests pass. The
+mandatory release journey now includes the actual Settings backup UI at desktop,
+phone and landscape sizes, error/retry and accessibility checks, synthetic backup
+transport, and real API role refusals before any private backup access. Full gate
+and production evidence remain release obligations, not assertions made here.
+The first browser run also exposed an over-broad new test selector: it matched
+the desktop shell ancestor and included an existing Terminal window. The backup
+journey now names its exact feature root without disabling any accessibility rule.
+The observed Terminal tablist/input-label findings remain separate UI debt, not
+fixed by this selector correction. Failure receipts now include assertion errors
+and an explicit pass flag; an empty page-error list alone is never success.
+History pagination is not resumable copying. Source-release review, complete and
+offsite backup, learning coverage and Jev admission remain separate open work.
+
+## 2026-09-26 — Memory safety and second-brain visibility
+
+Implemented fail-closed session-source preservation, preview/confirmation-first
+owner cleanup, private local server-memory snapshots with isolated restore
+verification, owner-only cross-principal graph discovery, paginated archived
+learning with explicit errors and graph-persistence warnings, and bounded
+Organization/workflow/recipe links in the pinned Memory app.
+
+Full source verification passes 3,528 tests across 607 files with type, lint,
+coverage, architecture, documentation, contrast and high/critical audit gates.
+Runtime deployment and browser acceptance require the normal release proof.
+Full resumable
+backup, source-release review UI, cache-only cleanup separation and Jev memory
+admission remain open. No session, archive, memory, evidence or Docker volume was
+deleted by this work. See [Memory safety](./MEMORY-SAFETY.md) for behavior,
+interfaces and honest limits; operational receipts remain outside public source.
+
+## 2026-09-25 — Native Google Integrations foundation
+
+Native Google OAuth app configuration, Search Console and Google Analytics 4 now
+use the existing Integrations identity/store and generic UI/CLI/MCP dispatch.
+The consumer UI selects an OAuth app and opens Google consent instead of a
+Composio project-key form. App-only configuration remains distinct from user
+consent and actual API verification. Six bounded read operations cover property
+listing, search analytics, sitemap metadata, stored URL inspection, GA account
+summaries and GA4 reports. No Google write/event-sending action is introduced.
+
+The callback uses single-use state, PKCE, a separate host-only browser binding,
+issuing Owner-device/policy checks and app/connection revision pins. Runtime
+Google grants stay out of shared/copy/export DTOs. Native user authorization and
+actual property access still require an operator's real Google consent; tests
+with synthetic identities do not establish a production connection.
+
+Verification: all 3,505 tests in 598 files passed with TypeScript, zero-warning lint,
+architecture/documentation/skill/contrast gates and the high/critical dependency audit.
+The isolated production build, bundle budget, mandatory release browser journeys,
+new native Google UI journey (20 synthetic-account checks, light/dark mobile/desktop),
+all five shell status/performance checks and existing role/cookie isolation passed.
+The new Google UI is included in the mandatory build gate. Real Google account consent
+and property access remain an operator follow-through, not a synthetic-test claim.
+
+The pre-deploy MCP audit caught an omitted public operation enum before any
+production update. Native Google action names now come from the same operation
+catalog used by dispatch and UI; private setup methods share their enum with the
+native registry. Eight actual MCP descriptor/call regressions cover both full and
+ChatGPT profiles, scope refusal, private app setup and safe browser handoff.
+The MCP toolset advances to `2026.09.25.1`; clients caching descriptors must refresh
+before invoking newly added operations. The global tool count is unchanged.
+
+This is not full Composio provider/trigger/UI parity. The user's global embed
+padding/margin request remains a separate deferred task. Setup, exact operations,
+security controls and remaining phases are documented in
+[Native Google Integrations](./INTEGRATIONS-NATIVE-GOOGLE.md).
+
+## 2026-09-24 — Add a first-class Memory graph
+
+MSO now has a Memory app (`/memory`, Launchpad and Spotlight “Memory”, CLI `mso memory-graph`) for a navigable knowledge graph. The owner-only `GET /api/v1/memory-graph` builds it from an optional markdown vault (`OS_MEMORY_GRAPH_ROOT` or a path typed in the app, jailed to `OS_FS_READ_ROOTS`), project `.mso/KNOWLEDGE.md`, bounded repo-local `.agent` memory, the signed-in device’s typed agent memory, and assistant memories. Unresolved `[[wikilinks]]` become ghost nodes; folders and projects color groups. The client offers web, radial, and layered layouts plus a local hop neighbourhood, and opens a note in Code on a second click, double-click, or Open. Layout ideas follow open-silong’s memory graph (MIT). This is not the Workflow session graph and does not require Obsidian. Production picks it up with `mso update` after the commit is on `origin/main`; a GitHub merge does not rebuild the systemd service by itself.
+
+## 2026-09-24 — Integrations Variables + native AI Providers tab
+
+Integrations now has metadata-only variables that alias an exact named connection without copying credentials. variable.set / variable.delete are part of the existing integration_manage authority, integration_query view=variables exposes only safe references, rename/delete invariants prevent stale aliases, and an existing pre-variable mcp/jev connection can project a JEV alias without hardcoding a user. Workflow Optimizer Jev mode resolves JEV by default while preserving an explicit diagnostic override; endpoint/token remain private in Integrations.
+
+The native Integrations Settings-style manager adds **Variables** and **AI Providers** under Manage. AI Providers reuses Alfa's existing /api/config, /api/models/providers, /api/models, /api/models/test, and /api/oauth/openai surfaces for active provider/model selection, API-key updates, tests, OpenAI authorization, custom providers and disconnect. It does not introduce a second AI credential store. The MCP Page keeps secret-bearing AI management browser-only and links into the native page.
+
+Verification: focused regressions passed 46/46 across 11 files; full `bun run verify` passed (typecheck, lint, coverage, architecture/check and audit); `scripts/verify-build.sh` passed the isolated Next.js production build, bundle budget, Chromium readiness, mandatory release E2E, native Integrations desktop/mobile/landscape journey, five shell server-status checks and deferred-shell performance.
+
+## 2026-09-24 — Add review-first Jev Flow Optimizer for Workflow Graph
+
+MSO Workflow Graph now has a compact optimizer path without adding another global MCP tool. The existing `workflow_graph` surface owns `optimize_preview` and `optimize_clone`: preview never mutates the source graph, while clone requires the exact current revision and creates a new draft only when at least one optimization candidate is selected. The original workflow remains immutable during optimization.
+
+Optimizer v1 deliberately separates host authority from probabilistic judgment. MSO derives the eligible transformations, preserves capability scope/auth/confirmation/audit boundaries, and can run fully deterministic. Safe presentation grouping collapses consecutive action/context nodes through existing `metadata.customNodes` without changing execution. Structural compaction is narrower: three or more consecutive calls to the same read-only MSO tool can become one sequential Loop node carrying the exact already-prepared arguments, and this requires explicit review opt-in because the output shape changes. Write/exec tools, branched topology and referenced intermediate outputs are not compacted by this pass.
+
+Jev is optional and acts only as a decision kernel. A named direct Project MCP Integration keeps its endpoint/bearer private, applies an exact optional tool allowlist, and exposes bounded `mcp.tools.list` / `mcp.tool` execution through the existing Integration authority. The adapter discovers the remote tool schema first and supports both the bounded-alternative `jev_decide` contract and typed `state/questions` evaluators. Jev receives a compact workflow/candidate summary rather than graph credentials or new executable calls; it cannot invent arguments or bypass MSO policy. Unsupported/unavailable Jev falls back deterministically, and Jev mode reports decision-shadow agreement against the deterministic baseline without double-running workflows or duplicating side effects.
+
+The native Workflows UI adds Optimize with Analyze / Create optimized draft, provider/risk/probability summaries, node/edge reduction, fallback evidence and shadow agreement. Targeted optimizer/integration/MCP tests, Workflow Graph regressions, integration-model regressions, TypeScript, ESLint, zero-cycle architecture checks, docs/contrast/skill/audit gates, isolated production build, bundle budget and the full desktop/mobile release E2E all pass.
+
+## 2026-09-23 — Bind public Dokploy build env to Docker build args
+
+The bounded Dokploy public-build environment operation now writes each approved public key to both the application runtime env and Docker build args before queueing one redeploy. This closes the staging gap where a value such as NEXT_PUBLIC_CONVEX_URL existed at runtime but Docker ARG still received an empty value during image build. Secret/server keys remain rejected, existing build secrets and unrelated build args are preserved, and an already-synchronized key is idempotent without another deploy.
+
+A credential-isolated regression verifies runtime env, build args, preservation of neighboring settings, single redeploy, idempotent reread, and no public value reflection in the operation result.
+
+## 2026-09-23 — Add native Channels for Telegram and Discord
+
+MSO now has a first-class **Channels** application and provider-neutral messaging runtime. Telegram and Discord are adapters over one shared channel contract rather than separate feature implementations. Channel records contain only routing metadata and exact native Integrations references; bot tokens and webhook secrets remain in Integrations.
+
+Telegram supports Bot API credential verification, outbound text, normalized webhook events and webhook-secret validation. Discord supports REST bot verification, outbound channel messages, signed Ed25519 Interactions including PING/PONG, and normalized command/component/modal events. Discord Gateway message ingestion is explicitly not claimed.
+
+Native Workflows gains `Channel Trigger` and `Channel Send` nodes. Verified inbound events use the existing Workflow Graph engine and durable session/run machinery instead of a parallel automation runtime. The Channels UI exposes connection health, enabled state, default target, workflow binding, provider inbound URL, test, edit/delete and test-message controls, with direct navigation back to Integrations when setup is missing.
+
+Focused provider/schema/store/API tests and TypeScript verification cover the new boundary. `docs/CHANNELS.md` records runtime, security and capability truth.
+## 2026-09-23 — Isolate Termux installations inside Ubuntu PRoot
+
+The Termux adapter now starts installation and the generated CLI launcher with a fresh guest environment, explicit Linux-only PATH and non-root owner. It rejects an Android Node/Bun runtime accidentally visible inside the guest, retains the legacy native launcher target while replacing its symlink, and supports bounded build workers, Node heap, resumable installs and a private persistent install log for low-memory tablets. Shell tests exercise the exact guest argv boundary, hostile inherited environment, argument forwarding and failed guest-runtime probes without installing packages. The launcher test reads its generated file directly instead of first checking filesystem metadata, avoiding a check/read race flagged by CodeQL.
+
+## 2026-09-23 — Restore quality gates after the MCP personal token release
+
+The personal access token and automatic session change on main grew the Settings token view and MCP store past the repository's strict line limit. The UI dialog is now its own component, and token administration, state mutation and record types are split into focused MCP modules while preserving the existing hashed-token storage, lock and revocation behavior. Settings connection instructions and CLI entry points remain aligned with the token flow. This restores lint for the current main feature without weakening the line limit.
+
+Typecheck, zero-warning ESLint, the full coverage suite (3,369 tests), architecture, docs, contrast, skill-flow, instance-literal and high/critical dependency audit passed after provisioning the repository's isolated Tool Forge fixture image on this host. One lock-contention test failed on the first highly concurrent run; it passed alone and in the clean full rerun. Hosted Semgrep initially rejected a valid but single-line Bash `case` PAT scope guard as a partial parse in strict mode; the equivalent multiline form has zero parser errors and zero findings under the exact pinned image and rule set.
+
+## 2026-09-22 — Reduce Organization and Workflow chrome after first production pass
+
+The first Organization/Workflow/n8n release fixed the structural problem but still left too much chrome around the actual work. This polish pass removes a second overview header, boxed summary metrics and card-within-card counters from Organization. Unit and seat directories now use one compact search/status row and denser cards with inline operational metadata. The overview Directory/Map control moves into the primary Organization header, project tabs lose explanatory filler, and the redundant cross-app shortcut block is removed from the Organization sidebar.
+
+Workflow drops the duplicated Active toggle + lifecycle selector in favor of one explicit Status control. The secondary keyboard-help sentence is removed from the canvas toolbar, cross-app shortcuts no longer occupy Workflow actions, and the seven horizontally scrolling detail tabs are replaced by a narrow vertical icon rail with accessible labels/tooltips. n8n keeps navigation links in its empty-state guidance but removes duplicate Workflows/Organization/Integrations buttons from the configured editor toolbar. These changes reduce visual density without removing capabilities or changing auth/execution ownership.
+
+TypeScript, focused ESLint, architecture/docs/contrast/skill checks, targeted regressions, production build and the full release browser journey all pass across desktop, mobile and landscape.
+
+## 2026-09-22 -- Match ext-apps widget discovery after ChatGPT ecosystem 404
+
+A browser-console capture finally exposed the host failure that ordinary MCP logs could not see. ChatGPT correctly selected the registered MSO app, exact action name and ui:// template pointer, but its internal /backend-api/ecosystem/widget request returned HTTP 404 for the Native probe, Block, List, Page and integration_setup_open. At the same time MSO's own telemetry showed successful resources/read for the product resources, proving that public HTTPS, OAuth, resource bytes and MCP MIME delivery were not the failing boundary. A private equality check also proved the stored OpenAI App binding matches the ChatGPT connector ID exactly, without printing the App ID.
+
+The remaining MSO compatibility gap was in registration/discovery normalization. MSO already emitted canonical _meta.ui.resourceUri, but unlike the official ext-apps helper it did not mirror that URI into the compatibility _meta["ui/resourceUri"] field, and resources/list discarded each resource's _meta.ui even though the helper keeps listing-level UI metadata for host indexing. All five resource-bound tools now publish both URI forms while keeping _meta.ui.resourceUri authoritative; resources/list preserves bounded resource _meta; Block retains its older openai/outputTemplate fallback and the other tools do not gain it.
+
+Because the failing ChatGPT widget URLs are cache/index keys, all four canonical resources were also advanced to fresh URIs: native-probe-v2, block-v5, list-v3 and page-v16. The immediately previous canonical URIs remain read-only aliases so already-scanned clients do not break, but are not advertised. Regression now locks flat/nested descriptor parity, listing-level resource metadata and previous-URI aliases. MCP server/toolset identity advances to 1.15.3 / 2026.09.22.2. Final visual acceptance still requires a fresh ChatGPT Scan Tools snapshot and a new app-selected conversation; success means the internal widget request no longer returns 404, the component is visibly mounted, and a real component action round-trip succeeds.
+
+## 2026-09-22 — Negotiate MCP Apps UI and expose host-boundary telemetry
+
+The Native UI probe proved that MSO's tool descriptor, `ui://` resource, MCP App MIME and static HTML were valid, yet direct host acceptance still returned the structured fallback. The missing server-side contract was capability negotiation: MSO advertised its Skills extension but never declared `io.modelcontextprotocol/ui` during either legacy `initialize` or modern `server/discover`. A host could therefore execute the tool successfully without having a negotiated MCP Apps presentation channel.
+
+MSO now advertises the UI extension with `text/html;profile=mcp-app` in both protocol eras while preserving ordinary structured/text fallback for non-UI clients. Owner-private protocol telemetry records only whether initialize/discover saw compatible client UI capabilities and whether `resources/list` / `resources/read` occurred, including bounded URI/MIME/state/duration metadata but never resource HTML or credentials. Regression covers bilateral negotiation and redacted resource lifecycle. The reference MCP Inspector reports the minimal probe as `hasApp:true` with the expected URI, model/app visibility, CSP and MCP App MIME.
+
+This release fixes the MSO-owned negotiation gap; it does not redefine visual acceptance. A generic Code Mode/function wrapper can still unwrap the inner tool result and cannot prove host mounting. Final ChatGPT acceptance remains a direct registered-app invocation after the refreshed server descriptor is active, with success defined by a visibly host-mounted `MSO NATIVE UI WORKS` component and then a real List → Page interaction round-trip.
+
+## 2026-09-22 — Split n8n from Workflows and make Organization/Workflow usable at scale
+
+The Organization project map had become visually unreadable on dense units because the initial canvas fit tried to show the entire graph at once. Organization is now directory-first: the owner sees searchable unit cards and operational counts, opens a unit into explicit Projects/Seats surfaces, and can switch to relationship maps only when topology matters. Seat browsing follows the same directory-first rule. Shared graph fitting now supports a representative readable initial cluster while preserving `F` as full-graph fit, and the Organization sidebar exposes direct Workflows, Integrations and System links without changing capability authority.
+
+External n8n is no longer a provider tab inside native Workflows. It is a first-class `/n8n` app/route with its own reviewed surface placement, cookie-isolated authentication boundary, responsive embed/fallback, and direct links back to native Workflows, Organization and Integrations. Legacy reviewed `workflows` placement remains readable during migration, while new registrations use `n8n`. Role-filtered or unavailable apps now show a neutral unavailable-state instead of the misleading `Unknown app` message.
+
+Native Workflows gained the missing core management pieces needed for practical n8n-style self-hosted parity: persistent owner-private data tables plus a `data_table` node; execution stop/retry/delete controls; portable `.mso-workflow.json` import/export; clearer Builder/Current run/Executions/Versions/Variables/Data/Directory panels; a denser workflow library; and toolbar overflow behavior that keeps wide action sets from pushing the canvas beyond its pane. Execution retry retains runtime input only in the private receipt, strips it from public receipts, requires the current graph revision to match, and stop remains cooperative at bounded node boundaries. Credentials remain owned by Integrations, Organization remains units/seats/projects/routing context, and Workflow remains automation topology/execution. `docs/N8N-PARITY.md` records the domain map rather than claiming pixel/API parity or copying n8n billing/marketplace administration.
+
+Verification on the isolated candidate: TypeScript, ESLint, architecture/docs/contrast/skills/instance-literal checks, the full coverage gate, production build, and the complete release E2E all pass, including dedicated n8n, Organization flow, custom graph, desktop/mobile/landscape reflow, data-table/portability/execution-control regressions, and no browser errors.
+
+## 2026-09-21 — Add bounded Repeat Until for reusable Session workflows
+
+Workflow Graph could already save successful/reviewable Session action history as a private workflow draft and invoke saved workflows through Subflow, but its graph schema deliberately rejected cyclic edges and the existing `loop` node only iterated arrays. That left ordinary automation patterns such as “run this saved task, inspect its result, and try again until ready” without a native bounded control-flow primitive.
+
+This release adds `Repeat Until` as a first-class Flow node without weakening the DAG safety boundary. A Repeat node references another saved Workflow Graph by `workflowId`, supplies its normal input plus `input.repeat.iteration` and the previous iteration result, reads the child workflow's explicit Output node, and evaluates a configurable result path. Exact JSON comparison is available through `equals`; omitting it uses truthiness. A match follows the `done` port, while reaching the configured iteration limit follows `exhausted`. Child failures still use the normal workflow error/retry semantics.
+
+The loop is intentionally bounded rather than an unrestricted visual back-edge: `maxIterations` is 1–50, inter-iteration delay is bounded, total repeat duration is capped below the parent run timeout, cross-workflow ancestry still rejects recursion, and every child execution receives its own persisted run receipt. The parent stores compact iteration metadata and final output instead of duplicating full child receipts. Existing acyclic graphs, item-loop behavior, Subflow, schedules/webhooks, and Session workflow drafts remain compatible.
+
+The Workflow inspector exposes the saved workflow selector, input bindings, condition path/value, iteration/delay/duration bounds, and `done` / `exhausted` ports. The Sessions view now makes the reuse path explicit: a reviewed “Save session as workflow draft” result can become the body of a Subflow or Repeat Until node. AI-assisted workflow drafting has the same bounded Repeat contract. Regression proves a saved child workflow matching on iteration three, the exhausted path after two iterations, Session draft behavior, graph layout, and existing flow controls. Full `bun run verify` and the official isolated production build/release E2E both pass.
+
+## 2026-09-20 — Add a static Native MCP App host-mount probe
+
+A fresh ChatGPT acceptance from this session still executed `render_mso_page("/integrations")` and `integration_setup_open` successfully but surfaced their decoded structured objects instead of mounting the declared MCP App resource. That repeats the same failure across Page, Block/List history and dedicated Integrations setup while current tool schema, registered-app binding and production package state are already refreshed.
+
+To isolate the remaining boundary without another Page/CSP/iframe rewrite, MSO now exposes one deliberately tiny read-only diagnostic tool, `mso_native_ui_probe`, bound only through standard `_meta.ui.resourceUri` to `ui://mso/native-probe-v1.html`. The resource is static dependency-free HTML containing only “MSO NATIVE UI WORKS”: no iframe, fetch, router, React bundle, bridge, tools/call, external domain or credential logic. It is advertised by normal `tools/list` and `resources/list/read`, included in the ChatGPT profile and generated MCP catalog, and has a tiny explicit output schema.
+
+This is diagnostic instrumentation, not a claim that Native UI is fixed. Server-side tests can prove descriptor/resource correctness only. Final acceptance still requires reconnect/rescan into the newly deployed toolset and a new conversation where the registered MSO App itself is selected; only a visibly host-mounted component satisfies the UI Definition of Done. If the static probe also degrades to ordinary structured output there, Page/Integrations/CSP/iframe code is excluded and the remaining defect is the ChatGPT host invocation/presentation-attachment boundary.
+
+## 2026-09-20 — Add durable server-native Local Agent standby
+
+ChatGPT/MCP local-agent collaboration previously had two useful but incomplete modes: a foreground `local_agent_inbox(wait_ms)` receiver that ended with the current request, and one-shot `local_agent_request` execution from a saved durable session. A coordinator therefore could not safely leave a session waiting, send it work later, receive the result, and keep the worker available without another manual user turn.
+
+This release adds `local_agent_standby` as an explicit exec-scoped control-plane primitive bound to the exact conversation session and active workflow. `listen` persists an owner-private standby record and returns immediately. A separate standby event channel rehydrates after process restart, rereads the durable mailbox to close subscribe/read races, atomically claims one authorized request, executes it through the existing durable-session/A2A task engine, emits the correlated reply, and returns the worker to `waiting`. Additional requests remain queued and drain sequentially. `stop`, `workflow_finish`, and `workflow_cancel` disarm the matching record; dispatch revalidates the workflow again immediately before model/tool execution.
+
+Authorization and observability remain fail-closed. `consumerConnected` still means a real foreground receiver and standby listeners never increment it. Directory/UI state exposes `standbyArmed`, standby state/workflow, actionable state, queue count, and current message separately. Only structured correlated requests persisted by an exec-scoped caller are executable; write-only callers may enqueue but cannot grant execution, while notify/reply mail never starts a worker. Standby workers reuse the original workflow actor internally and cannot start/finish/cancel a replacement workflow. Durable message claims plus a per-session execution lease prevent overlapping event/restart workers; after a crash MSO can recover an expired claim, but intentionally does not claim exactly-once external side effects across an abrupt process death.
+
+The implementation keeps the existing foreground inbox path, local one-shot request path, remote A2A protocol, and timed Workflow Graph wait node unchanged. Local Agent storage/dispatcher modules were split to stay inside the architecture line-count ratchet instead of raising policy limits. Targeted release regression covers immediate arm, disconnected-but-actionable presence, correlated execute/reply/waiting, duplicate event dedupe, sequential queueing, restart reconciliation, lifecycle disarm, stale workflow blocking, notify/write-scope non-execution, same-owner isolation, foreground inbox regression, local A2A worker reuse, fixed workflow propagation, MCP route/catalog/audit authorization, and Cockpit status projection.
+
+## 2026-09-20 — Stage MSO as a portable OpenAI Agent Plugin
+
+Native MCP App acceptance still returned structured data when the current ChatGPT conversation reached MSO through the generic orchestration wrapper. Server descriptors/resources were already correct, but the owner-private plugin package was legacy-only and staged rather than installed. Private staging now emits the current portable Agent Plugins layout: root `plugin.json` with `extensions.com.openai.apps`, the reviewed `claude-skills/` tree projected to root `skills/`, private redacted `.app.json`, and a rewritten `.codex-plugin/plugin.json` compatibility fallback. The doctor validates both manifests, the projected skill set, owner-only modes and registered-app binding without printing the App ID, and recognizes both portable and legacy cached installs. Repository `.app.json` remains empty and no MCP credential or maintainer-specific App ID is committed. This fixes the MSO-owned packaging gap; ChatGPT installation/refresh/selection remains host-owned and must be accepted from a new app-selected conversation.
+
+## 2026-09-20 — Distinguish Resend send-only scope from invalid credentials
+
+HR provider UAT exposed a verification-model bug: MSO's Resend doctor probed only `GET /domains`, so a legitimate Sending-only key could receive 401/403 and then be persisted as `invalid` even though that response only proved the key lacked Domains-read capability. The doctor now treats those Resend-specific scope denials as capability-unavailable with sending explicitly unverified, while preserving strict invalidation for providers/endpoints where 401/403 actually establishes invalid access. It does not claim a Sending-only key is valid, does not send a probe email, does not broaden permissions, and never exposes the credential. Regression coverage locks both Resend 401/403 handling and the connection-health classification.
+
+## 2026-09-20 — Make the Camoufox session stop leave a clean user unit
+
+Final production Browser QA proved viewer/auth transport clean, but stopping the Browser left
+`camoufox-vnc.service` in `failed (Result: timeout)`. The launcher installed a cleanup trap and
+then replaced itself with `exec websockify`, so the shell that owned the trap no longer existed.
+x11vnc could remain alive until systemd's 90-second stop timeout.
+
+The launcher now remains the service supervisor: websockify runs as a child, the shell waits for
+it, and the TERM path first asks x11vnc to stop through its X11 control channel before terminating
+remaining direct child jobs. The persistent profile, viewer cookie boundary, `Restart=no`,
+disabled-at-boot policy, and finite runtime lease are unchanged. Production acceptance requires
+the UI's final OFF state to correspond to `inactive/dead`, not merely `running=false`.
+
+## 2026-09-19 — Settle the Camoufox viewer ticket exchange before reloading noVNC
+
+Production Browser QA showed the split-origin ticket exchange returning HTTP 204, setting the
+host-only viewer cookie, and opening the encrypted noVNC WebSocket, while browser tooling still
+reported the POST to `/__viewer_auth` as `net::ERR_ABORTED`. Increasing the reload delay from
+50 ms through 800 ms did not change that result. A controlled production experiment isolated the
+actual boundary: when the bootstrap explicitly consumes the completed 204 response before
+navigating, the aborted-request report disappears while noVNC remains connected and the existing
+HttpOnly/Secure/SameSite=Strict host-only cookie boundary is unchanged. The bootstrap now consumes
+the response and marks the bodyless auth request `keepalive` before removing the ticket from the
+fragment and reloading. Regression coverage locks the settle-before-navigation ordering; no ticket,
+password, cockpit cookie, or viewer asset access is broadened.
+
+## 2026-09-19 — Memory v3 closes the learn → retrieve → expose → reuse loop
+
+- Memory mutation boundaries are now explicit: `agent_memory_remember`, verified `workflow_finish(success=true)`, user-facing Workflow create/save/restore (including session→draft), and Organization `flow_node_upsert`. Workflow/node domain receipts are bounded metadata only; graph configs, node notes, variable values and credentials are excluded.
+- Historical Gitleaks closeout: the two remaining findings were exact older fingerprints of deterministic SC-sync test fixtures. Added only those exact fingerprints to `.gitleaksignore`; a full 820-commit Gitleaks history scan now reports no leaks.
+
+- Replaced terminal/A2A first-12k head truncation with a frozen stable-core + query-relevant JIT memory projection. Defaults are 6k core / 8k JIT characters and are configurable without changing the durable typed-memory ledger.
+- Added deterministic bilingual/synonym normalization for bounded memory retrieval. The calibration improves from 4/6 to 6/6 lexical cases; the existing local semantic candidate stays 3/6, so vector memory remains blocked rather than adding complexity without recall benefit.
+- `workflow_start` compact structured output now carries selected agent/project memory plus the maturity-aware recipe plan, fixing the ChatGPT wrapper path that previously exposed only progress fields.
+- Learned recipes preserve prior intent phrasings as aliases. Telemetry now distinguishes recommendation from observed tool-route match/divergence instead of treating selection as proof of reuse.
+- Exact identical ordinary current `replace` writes now resolve to deterministic NOOP instead of growing redundant ledger history; explicit temporal/provenance timestamps and parallel `claim` evidence remain append-only. Retrieved memory keeps stable refs for audit, but retrieval alone is never labeled causal use.
+- Prompt projection strips hidden/bidi controls, neutralizes reserved memory-boundary tags and redacts secret-shaped material before model injection. Persistent memory remains evidence/context, never authorization.
+- Research boundary: adopts provider-neutral control-plane lessons from DeepSeek-V4.1-Flash (2609.19969), Hermes bounded frozen memory/on-demand recall, LongMemEval-V2 compact evidence gathering, and structured/evidence-aware ideas from Memory-R1, Hindsight, Mem0 and A-MEM. It does not import vendor model/KV code, require embeddings/graph storage, or weaken scope/promotion gates.
+- New/updated gates: memory context unit coverage, compact workflow-start projection coverage, recipe recommendation-vs-route-match regression, 6/6 lexical retrieval, 4/4 stable-core/JIT, 3/3 two-hop, existing 8/8 lifecycle and typed-memory deterministic suites.
+
+## 2026-09-19 — Separate ChatGPT native-app context from plugin staging
+
+Post-refresh acceptance proved that ChatGPT has the latest MSO tool schema but the currently selected orchestration path still returns `render_mso_block` as decoded structured data rather than mounting the MCP App. The server-side descriptor/resource/result contracts remain unchanged: the new evidence is at the host/package boundary. The owner-private OpenAI package was validly staged with a redacted registered-app binding, but this machine had neither a personal marketplace declaration nor a cached MSO plugin install. Staging on the VPS therefore did not install, publish, refresh, or select anything in ChatGPT.
+
+Added `plugin:doctor-private` plus a post-stage doctor that verifies private modes, the `.app.json` link and canonical binding while never printing the binding value, and reports local marketplace/cache state separately. The ChatGPT plugin reference now makes the acceptance boundary explicit: direct registered-app/app-context or an actually installed package is required for native UI verification; a generic function/Code Mode wrapper returning the inner object is not visual MCP Apps evidence. No MCP UI HTML, CSP, resource URI, OAuth behavior, tool scope, or personal App ID changed.
+
+## 2026-09-19 — Make compact MCP Apps standards-first and align plugin bindings with references
+
+A live ChatGPT test showed MSO render tools returning valid structured data without a visible
+component in the current nested connector/orchestration path. Server-side audit confirmed Page
+already implements the MCP Apps `ui/*` lifecycle, while compact List/Block still depended on
+ChatGPT-specific follow-up APIs for part of their interaction path. List v2 and Block v4 now share
+a standards-first bridge: `ui/initialize`, initialized/tool-result notifications, `ui/message`,
+host-context updates and teardown, with `window.openai` retained only as a capability-detected
+compatibility fallback. Old List v1 and Block v3 remain non-advertised read aliases so cached
+clients fail safely. Browser E2E now exercises the real compact postMessage lifecycle.
+
+The plugin/package audit also compared MSO against the saved Shopify, GitHub, Data Analytics,
+OpenAI Templates, Plugin Management, Google, Figma, Notion, Convex and Sites references. The
+`.app.json` validator now matches the documented canonical ID families, accepts optional/required
+booleans and snake/kebab aliases used by the references, and rejects persisted `plugin_...` URL
+identifiers. The linker normalizes a copied `plugin_asdk_app_...` identifier to canonical
+`asdk_app_...` before writing. All 18 saved reference manifests validate, and all 14 official MSO
+skills still pass their contract + `agents/openai.yaml` checks. No app ID is invented for MSO:
+the package mapping remains empty until an exact registered identity is supplied.
+
+## 2026-09-19 — Derive an isolated Camoufox sibling instead of assuming the managed-app namespace
+
+Camoufox viewer authentication no longer needs the cockpit Domain cookie, so tying its hostname
+to `{id}.mso.example.com` unnecessarily inherited deeper wildcard-certificate and cookie-scope
+constraints. The viewer now prefers an explicit `CAMOUFOX_VIEWER_ORIGIN`, otherwise derives a
+sibling outside the configured cookie namespace (`mso.example.com` → `camoufox.example.com`) or
+from a host-only cockpit origin. Overrides that share the cockpit host/cookie Domain, contain
+credentials, paths, queries, fragments or non-default ports fail closed. A broad two-label Domain
+has no safely inferable sibling and requires an explicit separate viewer origin. Managed-app host
+templates remain independent. A deployment shaped as `mso.operator.test` therefore resolves to
+`camoufox.operator.test` without any maintainer-specific source literal.
+
+## 2026-09-19 — Probe the cache-isolated Camoufox viewer entry path
+
+The viewer cache boundary moved noVNC under `/_mso-camoufox`, while the authenticated
+transport diagnostic still probed legacy `/vnc.html` with redirects forbidden. A healthy
+viewer therefore returned 307 and the Browser UI rejected it before requesting its viewer
+ticket. The public viewer prefix and entry path now live in one lightweight contract used by
+the gate, session metadata and server-side transport probe. The probe still sends no cockpit
+credentials, follows no redirects, requires HTTPS and keeps the existing SSRF/TLS checks.
+Targeted regressions verify the exact namespaced HEAD request, viewer gate, service route and
+client connection behavior.
+## 2026-09-19 — Separate AI connection from selection and harden public updates
+
+- OpenAI/Codex OAuth now connects credentials without changing Alfa's active provider/model unless the owner explicitly chooses **Connect & use**. Existing Google Gemini and other BYOK connections remain stored and selectable.
+- Alfa Cockpit can switch provider + model only among already-connected providers; credential creation/copy stays in Settings. A release browser journey proves Google Gemini → Codex → Google Gemini while both credentials remain connected.
+- Canonical MSO Git remotes are recognized across HTTPS/SSH forms and canonical SSH is normalized to the public HTTPS repository before install/update fetches. Git fetch/clone is non-interactive by default; explicit forks/private/custom `MSO_REPO` origins are never rewritten and retain their own `origin/main` authority.
+- Focused provider/updater regressions, full TypeScript/ESLint, production build and release E2E pass on the isolated candidate.
+
+## 2026-09-19 — Bind Convex snapshot authorization to the opened descriptor
+
+The prior staging hardening consumed bytes through one open descriptor but still authorized the
+caller path before opening it. `O_NOFOLLOW` protects only the final component, so a parent-path
+rename/symlink swap could otherwise redirect the later open outside the reviewed read root. Snapshot
+staging now re-runs `resolveReadable()` immediately after open, requires the caller-visible canonical
+path to be unchanged, and compares the named file's `dev`/`ino` to the descriptor `fstat`. The same
+identity check runs again after the private descriptor-only copy. An adversarial regression replaces
+the path after `open()` and proves the import is rejected rather than staging the old descriptor bytes
+under a now-different pathname.
+
+## 2026-09-19 — Pin Convex snapshot imports to validated bytes
+
+The security inventory exposed CodeQL alert #139: snapshot metadata was checked by
+pathname, then the same pathname was reopened for hashing and later passed to the
+Convex CLI. Snapshot validation now opens the source once, performs ownership/size/
+ZIP checks and hashing through that descriptor, copies those exact bytes into a private
+0700/0600 staging location, verifies the descriptor did not change during the copy,
+and imports only the staged file. The private copy is removed in a final cleanup path,
+while result metadata continues to identify the caller's original source path. Regression
+coverage changes the source after validation and proves the CLI still receives the
+validated staged bytes.
+
+## 2026-09-19 — Keep strict Semgrep coverage complete on the macOS installer
+
+Hosted Semgrep reported zero findings but exited 3 under `--strict` because its Bash parser
+partially parsed the heredoc nested inside `persist_path` in `scripts/install-macos.sh`. The
+installer now emits the exact same shell-profile block with literal `printf` arguments instead
+of that heredoc. `--strict` and `--error` remain enabled, the public dispatcher checksum is
+updated, `bash -n` stays clean and platform/install regressions pass. This fixes parser coverage
+rather than suppressing or downgrading the security scanner.
+
+## 2026-09-18 — Close graph routing review without changing executable topology
+
+PR review exposed four presentation/runtime issues: clear short facing ports could be mislabeled as overlaps, controlled parent selection could be ignored for existing nodes, each routed edge recomputed against the whole obstacle set during drag, and compact fitting could center arbitrary storage-order nodes instead of workflow triggers. The shared route scene now clamps/direct-routes short clear links, caches route geometry across unrelated movement, and is owned at the canvas boundary. Endpoint sibling ranks are built once per scene instead of rebuilding/sorting an adjacency union for every edge; after warm-up, a 25-run 200-node/400-edge synthetic scene build measured about 0.48 ms median on this host, while repeated unrelated movement reused all 400 cached routes. Controlled selection changes win while transient box/ctrl selections survive data-only updates. Compact focus derives from manual/schedule/webhook or semantic session roots and maps collapsed trigger members to their visible custom-group proxy. Grouping remains presentation metadata; stored nodes, handles, edges and execution semantics are unchanged.
+
+## 2026-09-18 — Selected custom nodes and visible connector routing
+
+- Complete selection-based named grouping in Workflow and Organization project canvases. Collapse/expand/ungroup retain original executable nodes, ports and edges; grouping is bounded, validated metadata in the existing private stores.
+- Preserve multi-selection and atomic group/multi-node movement; prune group membership only on explicit member deletion. Extend existing function-calling and CLI actions rather than inventing another store.
+- Replace unconditional smoothstep connectors with shared bounded orthogonal routing against measured cards, directional markers, crossing halos and selected-route emphasis. Impossible overlapping-card paths are visibly marked rather than silently claimed safe.
+- Verification is performed against synthetic stores and the real production build; private operator graph content is never embedded in source.
+
+## 2026-09-18 — Include the remaining reviewed public asset variants
+
+The first exact-main run of the path-scoped validator correctly failed because the live
+asset graph also contains content-hashed CSS chunks and Next's versioned SVG app icon.
+The raw report showed rule 10050 only on public cacheable assets. Header checks confirmed
+CSS is public/immutable for one year and the icon is public for one week. Extend the
+validator narrowly to CSS chunks and only the exact ?icon.<hash>.svg icon query shape;
+arbitrary queries, API/login paths, cross-origin URLs and all otherwise-unreviewed alerts
+still fail closed.
+
+## 2026-09-19 — MCP agent bootstrap and capability-parity map
+
+MCP clients were skipping `workflow_start` / `skills_search` and jumping to `exec_run` because
+the full `tools/list` had no explicit first-call contract. The canonical sequence now lives in
+`lib/mcp/instructions.ts` and is injected into `initialize.instructions`,
+`workflow_start.bootstrap.orientation`, and official skill `mso-agent-bootstrap` (ChatGPT
+published skill #1). ChatGPT still sees every callable MSO tool; project MCP discover/call stay
+two tools; secrets stay out of args. The parity matrix in `docs/AGENT-BOOTSTRAP.md` separates
+presentation differences from intentional Alfa identity boundaries. Catalog routing now matches
+orientation prompts to `skills_search`/`skills_read` instead of shell. Follow-ups (host file
+index, replay-by-handle) are documented, not shipped.
+
+## 2026-09-18 — Close external-editor review around durable session policy and owner stores
+
+The latest PR review found four boundary issues after the cookie-policy epoch landed. CLI device
+approve/role/revoke writes now preserve the durable `sessionPolicy` record instead of rewriting
+the auth store without it. Repeated session validation uses a read-only fast path when the stored
+scope already matches and acquires the cross-process mutation lock only for an actual rotation,
+with a locked recheck before writing. Workflow-only surface updates preserve MCP Page placement
+only from an existing row that itself normalizes as a valid reviewed app, so malformed legacy
+bytes cannot create Page approval. `MSO_SURFACE_APPS_FILE` is now one of the explicitly allowed
+owner security-store paths, so a configured registry outside the home directory remains writable
+without a duplicate filesystem-write-root declaration. Existing validated Page auth query metadata
+is preserved unchanged. Targeted regressions cover all four boundaries.
+
+## 2026-09-18 — Permanently revoke prior cookie-policy generations
+
+A follow-up security review found that a deterministic scope label could revive an old signed session if configuration later returned to the same cookie Domain. The private auth-device store now keeps one durable cookie-policy epoch and rotates it on every actual scope transition, including A to host-only to A. Signed browser sessions carry both scope and epoch; route and middleware/WebSocket authorization require both. Existing approved devices and roles are preserved, but pre-epoch sessions require a one-time sign-in. Workflow edits also preserve an existing reviewed MCP Page auth path with query parameters without allowing the Workflow endpoint to create or change that Page-owned metadata.
+
+## 2026-09-18 — Preserve the strictest reviewed external-editor sandbox
+
+PR review found that an explicit empty iframe sandbox was normalized as if the owner had
+omitted the field, causing the runtime default to add scripts, same-origin and forms.
+The surface registry now distinguishes omitted sandbox policy from an explicitly empty
+policy. Empty remains a valid, strict sandbox; non-empty values still use the same
+allowlist and byte bound. No permission token is added or broadened.
+
+## 2026-09-18 — Bind signed sessions to their cookie policy
+
+The external-editor security review found a migration edge case: after a broad Domain cookie
+is narrowed or unset, the browser can retain the old cookie until its original expiry even
+though logout no longer knows its former Domain. Session payloads now carry the normalized
+cookie policy that minted them, and both route authorization and middleware/WebSocket gates
+reject a valid HMAC when that policy no longer matches current configuration. Legacy tokens
+without a scope are intentionally invalidated once. This preserves safe host-only sibling
+editors such as a separately hosted n8n while making a retained broader Owner cookie unusable
+against MSO after a scope change. No cookie is widened, no secret is rotated, and current
+domain-match/host collision checks remain in place.
+
+## 2026-09-18 — Remount reviewed workflow editors when sandbox policy changes
+
+A focus refresh can tighten an existing external editor's sandbox without changing its id or origin.
+The embedded document must not keep the permissions from the previous navigation. The iframe key now
+includes the reviewed sandbox policy, so a policy change remounts the document before it can continue.
+Blocked destinations and cookie-isolated origins remain unchanged; no sandbox capability is added.
+
+## 2026-09-18 — Preserve existing MCP Page approval during Workflow metadata edits
+
+The shared registry review found that a Workflow-only save replaced a previously shared
+entry with only the Workflows placement. Preserve an existing explicit MCP Page placement,
+or the legacy implicit Page approval, while adding/updating the Workflow placement. New
+and Workflow-only entries still cannot acquire Page approval through this endpoint. Repeated
+saves, prior explicit/legacy grants and refusal of caller-supplied Page escalation are tested;
+revision checks, owner review, unrelated entries and cookie-scope rejection remain intact.
+
+## 2026-09-18 — Keep external editor links outside the cockpit session-cookie scope
+
+The pending external-editor review exposed a domain-cookie leak: different origins can
+still receive the same session cookie. A new shared surface policy reuses the validated
+session-cookie authority and also accounts for host-only cookies across different ports.
+External Workflow entries that would receive cockpit credentials now remain visible as
+blocked metadata but expose no iframe, editor link or login URL. The same unsafe entries
+are omitted from the MCP Page catalogue and cannot be resolved as Page routes. Registry
+approval never grants cookie trust; exact cockpit links remain remote-only. No cookie,
+TLS, CSP, same-origin or role protection is relaxed and provider sessions are untouched.
+
+Regression tests reproduce the previous unsafe URLs before the fix and cover domain/host
+scope, leading-dot/case normalization, suffix lookalikes, remote-only links, runtime policy
+refresh and shared readers. The browser journey additionally verifies the blocked panel
+and zero unsafe requests rather than interpreting a hidden iframe as sufficient isolation.
+
+## 2026-09-18 — Reviewed workflow provider tabs
+
+- Keep the native automation/session editor unchanged and mounted while switching to external workflow editors such as n8n. The new wrapper consumes explicit workflow placements in the existing owner-reviewed surface registry, not app-store HTML or credential values.
+- Share the registry outside the MCP transport without adding another store. Owner-only no-store metadata and revision-checked, explicitly reviewed configuration APIs/CLI preserve exact origins, unrelated entries, safe sandbox permissions and remote-only fallback. Configuration input cannot carry paths or credentials.
+- Workflow-only placements never grant an MCP Page nested-frame origin. Load frames only on demand, preserve editor state when switching, expose top-level sign-in/open/reload actions and keyboard-accessible tabs. Browser login remains external-service-owned; framing never means MCP token forwarding or authentication bypass.
+- Add registry/access tests and a mandatory isolated browser journey with synthetic stores. Live n8n frame checks wait for actual nonblank paint as well as visible controls; keep the synthetic approved parent and signed-out proof distinct from authenticated editor claims.
+- The strict release build caught project-wide tracing of the dynamic registry path. Mark that owner-local runtime read as a non-build input, matching other private stores; the warning-fatal release gate remains unchanged.
+
+## 2026-09-18 — Scope cache retrieval review to immutable asset paths
+
+PR review caught that a rule-wide 10050 INFO entry would also downgrade a future
+shared-cache exposure on an authenticated or user-specific URL. Rule 10050 is therefore
+removed from the rule-wide ZAP policy. Hosted and local DAST now validate the raw ZAP
+JSON: only same-origin, query-free /_next/static/chunks/*.js and
+/_next/static/media/*.woff2 instances are accepted for that rule; every other 10050
+instance and every otherwise-unreviewed alert remains a failing condition.
+
+## 2026-09-18 — Classify cache retrieval only for immutable public assets
+
+The first post-merge passive ZAP run against main produced one new default warning:
+rule 10050 (Retrieved from Cache) on five content-hashed _next/static JavaScript/font
+assets carrying an Age header. The report contained no authenticated, personal, or
+user-specific URL for that rule. Keep the signal visible as INFO for those intentionally
+cacheable public assets; do not use IGNORE, do not alter authenticated response caching,
+and leave every other unreviewed ZAP rule at its default warning/failure behavior.
+
+## 2026-09-18 — Require executed passive security scan evidence
+
+The security closeout found that the scheduled hosted ZAP workflow could report
+success while its only scan step was skipped when no target was configured. Add a
+dependency-free target guard before an unconditional passive scan. Missing, unsafe
+or credential-bearing targets fail without echoing their contents; existing scanner
+pins, passive scope, rule classifications and alert failures remain unchanged.
+Tests exercise the CLI refusal and workflow wiring. Security assurance guidance now
+separates successful code/dependency/secret checks from historical alert dismissals
+and passive-scan execution; no dismissal or badge attestation is performed.
+The first executed hosted scan exposed a second wiring error: the pinned ZAP action
+only forwarded its policy input when it found IGNORE entries. Pass the existing
+INFO-only file explicitly with `-c`; preserve all five informational findings, new
+warning failures and the original policy bytes rather than inventing new exceptions.
+
## 2026-09-18 — Keep private viewer routing client-verifiable
+ ## 2026-09-18 — Independent CI verification pilot
+
+ Related URL: https://github.com/rahmanef63/mso
+ [before: verification had no standalone structured CI receipt] → [after: an exact-SHA manual runner wraps committed gates with private reports, host/repository locks and fail-closed outcomes]. Batonly tracks migration acceptance. Security/release profiles remain BLOCKED until standalone scanner parity is actually verified; Actions, branch protections and production are not changed. Run `bun run test:ci`; fixtures do not attest product or security acceptance.
+
+
The PR review reproduced a deployment-compatibility regression: a hostname resolving
only to RFC1918, carrier-grade NAT or unique-local IPv6 was blocked by the generic
public-provider SSRF guard before the client's authenticated viewer could mount.
diff --cc package.json
index 8619bb8f,ccdabd29..456f2fc8
--- a/package.json
+++ b/package.json
@@@ -49,10 -47,15 +49,15 @@@
"check:instance-literals": "bun scripts/check-instance-literals.mjs",
"e2e:release": "node scripts/e2e/release.mjs",
"bundle:report": "node scripts/check-bundle.mjs --report-only",
- "bundle:check": "node scripts/check-bundle.mjs"
+ "bundle:check": "node scripts/check-bundle.mjs",
+ "ci:plan": "node scripts/ci/run.mjs --plan",
+ "ci:verify": "node scripts/ci/run.mjs --profile verify",
+ "ci:security": "node scripts/ci/run.mjs --profile security",
+ "ci:release": "node scripts/ci/run.mjs --profile release",
+ "test:ci": "node --test scripts/ci/contract.node.mjs"
},
"dependencies": {
- "@anthropic-ai/sdk": "^0.125.0",
+ "@anthropic-ai/sdk": "^0.127.0",
"@imgly/background-removal": "^1.7.0",
"@radix-ui/react-alert-dialog": "^1.1.16",
"@radix-ui/react-dialog": "^1.1.16",