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.
2026-11-04: restrict Markdown transcript file export
Markdown transcripts may contain server-provided content. The TUI now prints them for review and copying instead of writing that content directly to a local file. File flags are refused before fetching a session; the separate non-Markdown export is unchanged.
2026-11-04 — Complete audited frontend implementation follow-ups
The existing 55-group frontend audit is tracked in the implementation ledger, with per-slice source, behavior evidence and remaining acceptance limits. The previous foundation is on main through PR #270; this increment addresses its unresolved Settings credential remount, Composio selection/cache binding and external-frame readiness gaps, plus save/conflict/pending-action races found during verification.
Settings retains operational input in the existing exact-window memory store, tags sensitive drafts for selective cleanup, preserves nonsecret editor buffers at auth boundaries, orders session probes across logout and blocks navigation during submitted provider writes. Responsive drawers acquire focus on open, including Shortcuts; the actual full Settings remount and five-shell/two-theme focus regressions are wired into mandatory release journeys. Workspace saves acknowledge only the revision saved, video draft baselines come from their load, and Camoufox aborts its current operation on unmount. Workflow source copy/restore share the action lock and preserve newer edits. Composio uses an authorized explicit owner/connection and a credential-revision-bound cache; frame fallback says readiness is unknown instead of inferring success from load.
Composio session cache identity uses selected and backing connection UIDs plus the backing revision, without hashing credentials. Legacy projected connections bypass cache reads and writes because their identity and revision are not durable. Focused route tests cover rotation and shared-backing replacement.
Focused unit and mounted synthetic component checks passed during implementation. External headless fixtures cover selected five-shell/two-theme/320–844 samples with a prior CSS build; they are not exact-SHA release proof. Full local, pinned scanner and remote results must be recorded for the final commit before merge readiness; real devices, assistive technology and upstream vendor behavior remain explicit limits. No production deployment, host data or tunnel was changed.
2026-11-03: frontend contract for every feature and agent
Frontend rules were spread across product direction, shell design notes and the dynamic
foundation contract. docs/FRONTEND-CONTRACT.md now gives every feature one implementation
and acceptance contract: layer ownership, token/container layout, state lifetimes, asynchronous
recovery, icon/menu semantics, accessibility, themes and per-feature verification evidence.
Both root agent entry points and a scoped frontend/AGENTS.md require it. The docs gate checks
those links, including the shell/foundation references, so a later edit cannot silently detach
agent routing. This documents required practice and explicit migration limits; it does not
claim every existing feature has already been individually polished or exercised in production.
2026-11-03: compact credential actions and connection menus
Credential rows use labelled eye, copy and trash icon buttons with native tooltips. The connection action trigger uses an ellipsis; menu items retain text with leading icons. Owner pickers show a chevron and selected check without changing keyboard behaviour. The masked value reserves eight character widths so 200% text reflows controls instead of collapsing the value into a vertical column.
Copying keeps the displayed value masked. Reveal after Copy now opens the cached value instead of silently clearing it. Hide, the 30-second timeout and clipboard failures discard the cache. Pending reads disable both read actions. Destructive actions still require typed confirmation; cancellation restores the exact field action or the closed menu trigger.
The same native DOM helpers serve browser and embedded integrations. Targeted synthetic browser journeys, now required by the isolated build gate, cover these state transitions, deletion guards and keyboard focus, alongside the existing 320–1920 px light/dark layout checks. Release evidence is tracked by the PR.
2026-11-03: dynamic shell presentation and workspace recovery (local verification)
The shell manifest now accepts per-shell layout metrics. Feature frames can override those metrics while shared controls, dialogs and the Integrations iframe inherit the active values. Viewport projection preserves preferred window geometry across resize, shell changes and reload; layout persistence flushes before page exit and ignores malformed cache entries.
Mobile shells forward window identity to shared feature state. URL sync defers rewrites until a restored connected app appears in the asynchronous registry, preserving reload on phones.
Integrations uses opaque navigation, one sidebar scroll, initial compact-pane inert state, deduplicated account badges and an explicit same-origin ready handshake. Workflows adds a real Sources action, distinct empty/filter states and unsaved-change guards. Desktop widgets remain reachable after resize, the dock keeps a usable size floor, n8n refreshes cancel stale requests, and live System Monitor no longer displays a fabricated GPU gauge.
Validation and release status are recorded in docs/UI-UX-FOUNDATION.md. This entry describes
local work on the task branch; it does not claim deployment or release to main.
2026-11-03 (later): the security gate was gating itself
Two CodeQL alerts were open when this session started, and both turned out to be the same kind of problem: a check that measured the wrong thing.
#197 js/file-system-race, high, scripts/mso-agent-export-markdown.mjs:191
Real bug. The overwrite refusal was a check-then-write:
if (fs.existsSync(resolved) && !force) throw ...
fs.writeFileSync(resolved, content, "utf8");
Anything created between those lines was silently overwritten — the exact case the guard exists
to prevent. Fixed by letting the kernel decide: flag: "wx" creates-or-fails in one operation,
and EEXIST maps back to the same user-facing message. mkdir lost its existsSync too, since
recursive: true already treats an existing directory as success.
The first version of the test passed against the vulnerable code. It called the function
twice and checked it refused — but both shapes refuse in the same cases, so behaviour cannot
distinguish them. The difference is a window neither call can observe. Test 4b now spies on
writeFileSync and requires the exclusive flag:
red (old shape): expected [ undefined ] to include 'wx'
green (fix): 7/7
#137 Scorecard SASTID, "29 of 30 commits checked"
Not a finding. A closed loop in CI, which is why it had been open since 2026-09-17:
one open alert -> CodeQL analysis run red
red analysis -> Scorecard counts that commit as not SAST-checked
its SASTID alert stays open -> keeps the analysis step red
codeql.yml ran security-alerts.mjs in failing mode inside the analysis job, while
security-alerts.yml already gated on the same inventory. Two gates, one of them self-defeating:
57 of the last 100 CodeQL runs on main were red, every one reporting
CODE_SCANNING_OPEN 1 — the Scorecard alert, never a code finding.
The analysis step now passes --inventory (report, annotate, exit 0). security-alerts.yml
keeps the failing gate, unchanged.
And the test had the loop baked in: scripts/security-alerts.test.ts asserted that
codeql.yml may never contain --inventory. Written to stop a gate being weakened, it
required the duplicate that caused the loop. The invariant is "exactly one gate", not "two", so
it now asserts report-only for codeql.yml and still-strict for security-alerts.yml. Red first:
removing --inventory fails with expected false to be true.
Result
open code-scanning alerts 0 (#137 and #197 both fixed)
dependabot alerts 0
bun run coverage 1009 files / 6562 tests, rc=0
audit.mjs --strict clean at high/critical
main 4c69c354, tree clean, remote heads: main only
open PRs 0
all workflows on main success (Security alert inventory included)
Lesson worth keeping: a red gate is evidence only if it measures the thing it claims to. Two of these three defects were in the checks, not the code.
Still open
perf-baseline.jsonpredates several dependency bumps; re-measure on an idle host.- Local branches from other tracks remain under
~/.cache/mso-worktreesand own their worktrees. Left alone.
2026-11-03: integrations UI closed out, and one merged fix that had been silently deleted
Everything below is merged. main at 269b6721, working tree clean, gate green.
The finding that matters most
PR #248 fixed four integration-UI defects, each with a test. PR #249 (unrelated TUI feature work) overwrote two of the same files with stale copies, removing the code and the assertions that pinned it. The gate stayed green because the tests vanished with the behaviour.
What was actually gone from main, verified by reading the files rather than trusting the merge log:
role="alertdialog" on the delete confirmation missing
Escape / focus return on that dialog missing
.transfer-error styling missing
.connection-state wrapping missing
Found by a browser audit, not by CI. lib/infra/integration-ui-regressions.test.ts now asserts them
by behaviour, reading the source directly, so replacing a file wholesale fails there even if the
original tests disappear with it.
Lesson: a green gate after a merge proves nothing about whether the merge kept the previous work. A test file that a later PR can delete is not a guard.
Browser evidence, and why string tests kept lying
Two UI claims in this work passed their tests while the browser disagreed:
| claim | what the test checked | what the browser did |
|---|---|---|
| iOS auto-zoom fixed | input[type=search] |
page uses .integration .integration-sidebar-header>input[type=search], still 12px |
| theme follows the shell | the two backgrounds differ | they differed because the OS differed, not because the app chose |
scripts/integrations-ui-evidence.mjs now drives four viewports, light and dark, and a 240px-tall
iframe, checking horizontal overflow, one main, one h1, 44px tap targets, accessible names, alt
text, the 16px input threshold, keyboard reachability, focus visibility, console errors, and that a
dark preference produces dark tokens. 43/43 on the current build.
Keyboard defects closed
| defect | evidence |
|---|---|
skip link pointed at #main-content, which wraps the menu bar, and was not focusable |
hash=#shell-main, activeElement=SECTION#shell-main |
| closed mobile drawer left 30 items in the tab order (31 invisible stops) | 10 Tabs, zero off-screen stops |
| full-screen backdrop ignored Escape (handler lived on the panel) | Escape sets data-open="false" |
<details> "More" popover had no Escape and no outside-click close |
both handled, focus returns to summary |
Every shell (macOS, Windows, mobile) now carries #shell-main with role="main" and tabIndex={-1}.
A regression I caused, caught by the release E2E
Marking the sidebar inert whenever data-open was false also hit the desktop layout, where the
sidebar is a permanent visible column with data-open="false". Every nav button became unclickable:
waiting for getByRole('button', { name: /^Convex$/ })
<div class="integration-settings-shell"> intercepts pointer events
verify-build.sh caught it; the unit suite did not. The inert is now scoped to the 37.5rem compact
breakpoint, matching the CSS rule that does the translating.
Dependencies, without force-merging
Four Dependabot PRs could not merge cleanly. Each was rebased, bun installed and gated on its own
branch rather than merged as-is, because a lockfile resolved against an older tree is a guess.
@anthropic-ai/sdk 0.135.0 -> 1.3.0 is a major jump, so it was verified at runtime
(messages.stream is a function, constructor works) and then 6434 tests passed.
The gate they were all failing was my own: it listed dependency bumps as user-facing changelog
entries. It then failed a second time in a subtler way — the file depended on when it was
regenerated, because a squash appends " (#NNN)" to the subject. That one was CI-only: local passed
while GitHub's PR merge ref, which includes the squash, reported stale.
Traps that cost real time
- A parallel track moved this session's worktree to
maintwice mid-run. Commits appeared lost; recovered from the reflog, then all further work moved to a dedicated worktree with a symlinkednode_modules. /tmpfilled to 78% with three out-of-tree builds. The release E2E reported it asverification failed during mandatory release E2E, which reads exactly like a code failure. Cleaned; re-ran; passed.- A stale build directory made three evidence runs report false failures. After changing source, the harness must be rebuilt; check the build's own files before believing a red result.
git stash popaftergit checkout mainsilently dropped a change that the merge had already taken;gen-changelog --checkcaught it, nothing else would have.
Deliberately not changed
Disabled buttons render at opacity .55, giving 2.26:1 on "Add connection". WCAG 1.4.3 exempts
disabled controls, so it is not a violation, but it reads as a broken button rather than a
deliberately inactive one. The honest fix is a disabled state built from color/background
instead of opacity, which is a design decision, not a bug fix.
Open
perf-baseline.jsonpredates several dependency bumps. Re-measure on an idle host before trusting the TBT comparison.- Three remote branches were left over and all already merged; deleted.
2026-11-01: the green full run, and the parallel-run trap
bash scripts/gates-12.sh full on the TUI panel branch: passed=16, failed=0, skipped=1. The
single skip is bundle budget, which is enforced by verify-build.sh inside the same run rather
than twice, so a skip there means the out-of-tree build already checked it.
The red runs before it were not real. Two gates-12.sh full invocations were left running in
the same worktree at once. They do not fail cleanly, they corrupt each other:
tests + coveragefailed because both wrote the coverage output directory and removed it from under the other, so vitest reported a script error rather than a threshold miss.production buildfailed with "verification failed during mandatory release E2E" becauseverify-build.shcopies the tree into/tmpper run, and two copies exhausted the 9.8 GB tmpfs. The real error wascp: error writing ... No space left on device, three lines above the verification message.
Both passed once a single run had the machine to itself. A killed run also leaves verify-build.sh
orphaned with ppid 1, still holding a /tmp tree, so killing the gate is not enough to free the
disk: check for survivors before starting another.
Rule: one gates-12.sh run per worktree, never in parallel, not even fast alongside full.
They share /tmp/gate-out.txt and /tmp itself, so the outputs describe each other's failures.
The coverage numbers, from one run alone. bun run coverage with no other vitest in the worktree
and the stale coverage/ directory removed first: 964 test files, 6,278 tests, all passing;
statements 53.72%, branches 50.47%, functions 42.63%, lines 57.5% against thresholds of 42 / 40 / 32 /
43.5. The earlier failure was never a threshold miss. It was vitest refusing to start:
The coverage report directory ".../mso-flip/coverage" is already in use by another Vitest process
(pid ...). Running coverage for multiple Vitest processes in the same directory at the same time is
not supported, because they would delete each other's reports.
That message names the cause precisely, so it is worth reading before assuming a regression: vitest detects the collision itself.
One more trap, in the tooling rather than the code. pgrep -f "vitest run --coverage" always
reports a live process, because the pattern matches the bash -c wrapper line that is the command
you just ran. The same is true of pgrep -f "gates-12.sh". Use
pgrep -af "node .*vitest" | grep -v "bash -c" to see what is actually running, or the check will
insist the worktree is busy forever.
2026-10-31: the LCP lever in the handover was the wrong lever
The handover said the cheapest untried LCP lever was taking wallpaper artwork off the critical
path. Measured first, and it is not a lever at all. Mobile's LCP element is
IMG.shell-artwork-macos — app-icon artwork, 60x60 — while the wallpaper is a CSS background.
Emptying every image byte on the live build (artwork + wallpaper, 331 KB) moved LCP
3020 -> 2996 ms, inside the noise band. LCP is bound to lastJs (~2.75 s) plus mount cost.
Method note that cost a run: route.abort() on image requests makes the browser retry, so the
first experiment showed 47 -> 179 requests and looked like a regression. route.fulfill() with a
1x1 body measures what was intended.
What the images actually cost
Three <img> per app tile (default, macOS, Windows), two always hidden by CSS. Mobile: 231
artwork <img> in the DOM for 77 displayed, 370,926 bytes across 47 requests, with
/app-icons 71,526 + /app-icons/macos 159,258 + /app-icons/windows 81,784 — two of three
families never painting.
The three-variant markup was justified by a comment claiming SSR would guess the shell.
curl / returns zero shell-artwork occurrences, so none of it is server-rendered and
useActiveShell() already knows the answer at render time. Now one <img> per tile: 77/29 in
the DOM, 19 image requests, 217,616 bytes mobile. No CSS change.
Eager graph: -26.7 KiB gzip
Three things sat in the first-load bundle without being needed to paint:
| What | Why it was dead weight |
|---|---|
Alfa/chat surface re-exported from appshell/index.ts |
all 14 consumers are lazy (chat-panel, chat-transcript, inspector, alfa-sheet, use-host-commands, os-settings) |
auth panels in auth/index.ts |
consumed only by /login, install, login-page, os-settings |
| widgets + shortcut-help via static imports | search/control-center/inspector already used DeferredSurface |
Moved to @/features/appshell/alfa and frontend/slices/auth/panels.ts; widgets and
shortcut-help now defer through the same primitive while their hooks (registry, context menu,
command palette, the ⌘/ wrapper handler) stay eager.
entry 141.2 -> 114.5 KiB gzip (416.8 -> 326.5 KiB raw, 13 -> 12 files)
initial 270.8 -> 244.0 KiB gzip (850.5 -> 760.2 KiB raw, 18 -> 17 files)
Lock-screen was deliberately not deferred. organization/bundle-boundary.test.ts pins it
because it owns the idle auto-lock timer; deferring it means auto-lock does not arm until someone
opens the lock screen. A security regression is not worth ~4 KiB.
LCP, against a pristine-HEAD control build
Both sides under releaseFixture, 5 interleaved runs. Comparing against the live :4005 first was
misleading: it serves real data, and fixture-vs-fixture is the only honest pair.
| surface | head | this branch | delta |
|---|---|---|---|
| desktop | 3332 ms | 3160 ms | -172 ms |
| mobile | 3076 ms | 2872 ms | -204 ms |
| mounted | 2592 / 2562 | 2409 / 2439 | -183 / -123 ms |
lastJs reads higher (2846 -> 3105) because deferred chunks now download after mount instead
of before it. Behaviour re-checked against the old build: ⌘/ still opens the cheat sheet and
closes on both Escape and a second ⌘/, mobile still renders 4 widget cards, desktop 3, CLS
unchanged (0.0005 vs 0.001 desktop, 0 both mobile).
The gate could not read the new budget
Tightening the budget exposed a gate reading the wrong tree. .next is never built in place
here, so it belongs to whatever was built last — usually a different commit. gates-12.sh full
ran check-bundle before verify-build.sh, and fast mode ran it with no build at all, so a
lowered budget failed against bytes describing history and read like a regression.
Fixed: check-bundle now detects a stale build and says so; fast mode reports bytes without
enforcing; full mode leaves enforcement to verify-build.sh against its own out-of-tree build;
bundle-budget.json drops to entry 119,540 / initial 252,219 with the same +2.0 % arithmetic.
Two security jobs were red on main before this branch
Both fail identically on main (41214069060):
- Gitleaks — two findings, same fixture line of
app/api/internal/socket-policy/route.test.ts:"test-secret-at-least-32-characters-long-policy-key". The route module is mocked in that same file, so nothing leaves the process. Allowlisted by exact commit/file/rule/line after verifying with the pinned scanner the workflow uses:leaks found: 2->no leaks found. - OSV —
[email protected]and@10.2.6, one medium advisory (GHSA-g3hv-75wg-m249, glob-parts amplification, CVSS 6.9). Left unfixed on purpose: the patch is[email protected], which is ESM-only, and@typescript-eslint/typescript-estreeneeds the 10.x line. Forcing it is a breaking dependency change and does not belong in a perf PR.
Traps that cost real time, again
- Worked on someone else's branch. The working tree was on
fix/tui-pty-bugs, notmain, and three commits landed there. Recovered: that branch was reset to its original0425ec8c(its TUI work was already identical toorigin/main#201, so nothing was lost) and the commits moved toperf/eager-graph-artworkrebased ontoorigin/main. - A
git addin a shared working tree swept six throwaway probe scripts into another track's commit (80adb801). Removed in860b4c07. The lesson is not "commit faster" — it is that a second track committing in the same tree willaddwhatever is lying around. /tmpfilled to 99 % with three out-of-tree builds at 2.3 GB each.production buildfailed withFailed to write uploadin the 200 MiB E2E, which looks exactly like a code bug. The pristine-HEAD control failed identically until/tmpwas cleaned. The handover warned about this one.- Running the gitleaks container with
-v "$PWD:/repo"left 67 files in.gitowned by root, because it is a partial clone (blob:none) and git inside the container promisor-fetched and rewrote refs.sudoneeds a password here. Fixed withdocker run --rm -v "$PWD/.git:/g" alpine chown -R 1000:1000 /g;git fsck --connectivity-onlyclean afterwards. Use-v "$PWD/.git:/repo/.git:ro"next time, or a--user "$(id -u)"flag.
Why CI looks silent on a feature branch — it is not broken
I recorded "the missing workflow triggers on the latest head are unexplained". That was wrong, and worth correcting rather than leaving in the record: it was a misread trigger configuration, not a GitHub fault.
.github/workflows/ci.yml triggers on push.branches: [main, "security/**"] and on
pull_request.branches: [main]. A push to any other branch therefore fires nothing. Every CI
run this branch ever got arrived through the pull_request event, one per PR head push. Over the
last 30 CI runs on the repo, 13 are push and all 13 are main.
So "CI stopped firing after b2cffa6a" means exactly one thing: no PR head was pushed after that
commit. Local commits that are not pushed are not part of any PR, so there is nothing for GitHub
to test. Nothing is stuck. The corollary is the useful part: the only way to get CI on a
non-main branch is to move that branch's PR head, and a rebase that stays local changes nothing.
workflow_dispatch exists in the same file, but it cannot stand in for push-triggered CI here:
a dispatched run executes against the workflow file on the ref you dispatch at — which for
GitHub UI and the API means a ref that already exists on the remote. Since the whole point is to
test commits that have not been pushed, dispatching can only ever test what is already visible to
GitHub, i.e. the same 7c4569ae the PR already shows. It is useful to re-run a flaky job on an
existing ref, not as evidence for unpushed work. The pull_request run is the proof, and it needs
the push first.
Open
- PR #207 — branch
perf/eager-graph-artwork. Remote head is7c4569ae(7 commits, CI green onVerify,Native hostmacOS + Windows,CodeQL,Dependency Review); local is rebased further ontoorigin/mainand not pushed, so the PR still reports the older head and staysmergeable_state: dirtyagainst amainthat has moved. Pushing it is a force-push and needs the owner's explicit go-ahead. perf-baseline.jsonwas regenerated after all (commitba13b20b), on an idle host: desktop LCP 3222 → 3044 ms / TBT 164 → 81 ms, mobile LCP 3054 → 2740 ms / TBT 132 → 81 ms. An earlier revision of this entry said it had been skipped because load sat between 7 and 19; the harness was then taught to wait for load1 < 1.5 and to discard runs whose own recorded load exceeded it, one of four attempts was discarded that way, and the median of the three clean runs is what is committed.- Phase 5 (full SvelteKit swap) untouched, still needs the owner's 8-12 month decision.
2026-10-31: every route has a test, and the workflow conflict that made each PR slow
Route test coverage went from 59 of 117 to 117 of 117. No route in the repository is untested. Tests went 5,844 -> 6,194; statements 53.23 -> 53.79, branches 50.01 -> 50.46, lines 56.93 -> 57.6. Test files 873 -> 953.
How it was split. Six parallel batches on disjoint paths, each with a contract rather than "add tests":
| Batch | The assertion that matters |
|---|---|
.well-known + a2a |
these are public by design — the test proves they stay public and keep the exact keys MCP clients read. A well-meaning "harden this" would break every client |
| public probes | internal/socket-policy must return 404 specifically when its secret is wrong or short; it hides its own existence, so encoding 401 would be the wrong contract |
| integrations | Google start is owner-gated and must carry a state param; callback must reject a mismatched host and malformed state |
| misc v1 | federation/status and app-catalog differ — 401 unauthorized vs 403 owner_required — and that difference is the contract |
| sys + camoufox | camoufox/session returns 503 viewer_unconfigured on a short secret; managed-apps jobs distinguish unknown-app from unknown-job with separate keys |
| fs + auth | auth/me is the probe the shell boots on, so a wrong answer breaks start-up; auth/logout must clear cookies and not 500 when there was no session |
app/api/skills, the last one, has the most interesting branch in the router. A bare skill
name matching several projects returns 409 ambiguous with candidates — not 404, and not a
guess — because returning one project's instructions under another project's name is the bug
that branch exists to prevent. Mutation-tested: replacing the 409 with a guess fails the
assertion, restoring returns 8/8.
A real gap closed earlier in the same push: fs/read was the only fs route with no rate
limit while every sibling was throttled. It now carries 60/min plus an audit entry, and
fs.read joined the AuditAction union. That required fixing lib/mcp/fs-credential-boundary.test.ts,
which drives the route to prove the credential boundary — with the limiter live, ten
back-to-back reads would have returned 429 and a refusal would have been indistinguishable
from throttling. The limiter is stubbed open there, and the suite was re-verified to still
bite: disabling isCredentialPath gives 12 failed | 1 passed.
Every file was mutation-tested. Removing the guard a test covers had to make it fail:
verifyAuth deleted from a handler yields 200 instead of 401, rateLimited removed yields 200
instead of 429, IS_DEMO removed yields 202 instead of 403, the manager route returning 500
fails its 200 assertion. This discipline exists because a cannot-fail test shipped earlier in
this work — getSessionActor always resolved, so deleting exec/run's gate left the suite
14/14 green — and was counted as coverage.
Workflow fix. .gitattributes now marks docs/CHANGELOG.md as merge=ours. It is derived
from git history and rewritten wholesale on regeneration, so two branches that both regenerate
it always conflict textually even though neither is wrong, and the only correct resolution is to
regenerate — which the changelog gate enforces anyway. That single file cost three rebases on
one PR this session. The attribute is inert until a clone runs git config merge.ours.driver true, so an unconfigured clone still conflicts rather than silently merging.
Findings recorded rather than papered over. fs routes do no path validation at the route
layer — roots-escape enforcement lives entirely in the host primitives, which throw HostError
and surface as 400. That is a legitimate design, but it means those route tests prove the
delegation exists, not that containment is correct. Three infra routes collapse a wrong-role
caller into 401 rather than 403, and infra/setup returns 403 even when completely
unauthenticated — inconsistent with every other route, but pre-existing, so documented in the
test rather than changed here.
Evidence. typecheck 0, lint 0, check-architecture healthy at 42/43 (improved from
43/43), check-docs current, full vitest 953 files / 6,194 tests passed, coverage
53.79 / 50.46 / 42.64 / 57.6.
2026-10-30: Svelte marginal-cost retraction, status-code contract, and the CI-parity gate
Four findings where empirical measurement corrected assumptions and hardened safety boundaries.
The "2.8×" retraction and marginal component costs. Phase 4 was originally cancelled on the claim that "one Svelte component costs 2.8× the whole React slice it replaces" (17.75 KiB vs. 6.27 KiB). That comparison was flawed: it compared a Svelte build including the Svelte runtime against a React slice chunk that excluded the React runtime (which the shell had already paid for). Compiling the same component 1, 2, 3, 5, 9, and 10 times into a single bundle revealed the actual marginal cost: 17.74 / 17.75 / 17.80 / 17.86 / 17.96 / 17.99 KiB gzip. The Svelte runtime is ~17.7 KiB paid once, and each additional component costs ~0.03 KiB (all nine system-monitor components together are ~17.96 KiB). Phase 4 remains cancelled, but for the correct architectural reason: in a hybrid shell, Svelte adds a second ~17.7 KiB runtime beside React without removing React's 132.7 KiB floor, producing a net +11.7 KiB regression even after the slice's own 6.27 KiB is removed. Phase 5 is completely unaffected: React is replaced rather than joined, swapping 132.7 KiB out for 33.07 KiB in (−99.6 KiB net measured reduction).
The status-code contract and the cannot-fail harness bug. Mechanical extraction of 107 route
handlers left a critical gap: an audit confirmed current parity, but nothing prevented future
refactors from accidentally dropping auth checks. app/api/status-contract.test.ts locked down a
15-assertion contract across the 20 most dangerous routes where a dropped gate is an RCE (exec/run),
arbitrary file write/delete (fs/write, fs/delete), secret leak (agent-vault, fs/raw), or role
escalation (mcp/tokens, auth/devices). Writing it surfaced a dangerous harness bug: the mock
getSessionActor always resolved to "dev-1" regardless of the auth flag. Deleting verifyAuth
from exec/run still left the route treated as authenticated through the session actor, keeping the
suite 14/14 green. Because a test that cannot fail is worse than no test (it is falsely cited as
coverage), getSessionActor was rewired to follow the auth flag. Running mutation testing confirmed
the fix: removing verifyAuth from exec/run produced 1 failed | 13 passed, and restoring it
yielded 15 passed. (The suite also documents that fs/raw has two independent gates—verifyAuth
and getSessionActor—so defence in depth holds even if either is dropped alone).
Comment restoration on mechanical routes. The refactor that moved 107 route handler bodies
passed all behavior audits, but stripped critical context: 55 routes lost their design rationale.
Restored 33 security-and-visibility comment blocks across 28 files explaining why routes are public
(e.g., /api/health as an unauthenticated systemd WatchdogSec and Dokploy liveness probe), why
they are owner-only, or why they reside under specific paths (e.g., /api/mcp/tokens kept under
/api for cookie auth and proxy depth-2 CSRF gating, and /api/changelog session-gated so
unauthenticated visitors cannot enumerate deployment specifics). A naive first attempt split
multi-line comments line-by-line, creating fragmented syntax errors; this was redone cleanly
block-by-block.
Three defects surfaced by the CI-parity gate. Aligning local validation with CI via
gates-12.sh full ran vitest run --coverage and provisioned the Forge container sandbox,
immediately revealing three latent bugs:
provision-forge-sandbox.shbuilt an unstartable image (exec: /usr/bin/node: permission denied) from three compounded issues:installpreserved the host uid 1000 ownership (fixed by tarring with--owner=0 --group=0),umask 077created/usrand/usr/binasdrwx------which failed under container--cap-drop ALLlackingCAP_DAC_OVERRIDE(fixed by normalizing directory modes to0755), and a blanket filechmod 0644cleared the executable bit onld-linuxand dynamic libraries (fixed by restricting permissions normalization to directories only, preserving 0755 on binaries).lib/host/fs-zip.test.tsassumedos.tmpdir()was private and countedos-zip-*directories globally. Under vitest's multi-worker coverage pool, concurrent test workers created and cleaned temp directories simultaneously, causing spurious failures. The test was rewritten to scope assertions strictly to directories appearing during its own measured execution phase.- Consequently,
bun run coveragewent from 3 failed to 0 failed across 882 files / 5,772 tests.
Evidence. typecheck 0, lint 0, check-cycles 2174 files / 0 cycles, check-architecture
healthy at 43/43, check-docs current, gates-12.sh full 17 passed / 0 failed / 0 skipped, full
vitest 887 files / 5,826 tests passed.
2026-10-29: Phase 2 finished, bun install fixed, and Phase 6 measured out of existence
Three results, two of which were earned by measurement rather than assumed.
Phase 2 is done. Every one of the 117 route handlers is now a thin adapter (median 40 LOC
before, all ≤ 15 after, largest was 219), and lib/ has zero static next/* imports — one
documented dynamic import("next/headers") seam remains in lib/auth/require-session.ts because
cookies() is request-scoped plumbing with no web-standard equivalent. Bodies moved to a
colocated handler.ts, or to lib/ only when they were already framework-free.
Two regressions were caught before they reached main, and both are worth recording because the guards were the thing that caught them, not review:
- Three workflow services first landed in
lib/importing@/lib/mcp/*, which trippednonMcpMcpImports(7 / max 0). They moved back toapp/api/v1/workflows/asroute-read.tsand friends, following the patterna2aalready used. A ratchet, not a reviewer, found a real boundary violation. - Moving bodies into
lib/carriedimport { NextResponse } from "next/server"with them, solib next/*went 0 → 23 immediately after Phase 2 had just achieved 0. All 23 were converted to the web-standardResponse; the count is back to 0 and grep-verified.
One route test needed updating rather than the code: scripts/mso-model-dx-contract.test.ts
asserted on request parsing by reading app/api/config/route.ts, and now reads handler.ts,
which owns that logic. Behaviour was verified by diffing status/error strings per route and by
probing a live fixture — every endpoint still answers with its original status and body,
including the case where /api/status says "Unauthorized" while its neighbours say
"unauthorized". Seven routes deliberately keep bespoke auth because requireOwner would have
changed their status code or check order.
bun install now works from a clean tree. The blocker was real: [email protected] ships no
linux-x64 prebuild (upstream excluded Linux deliberately), so a native build is required, and
npm survives only because @npmcli/run-script injects its own node-gyp-bin into PATH. The
compiler was never missing — calling npm's node-gyp.js directly builds pty.node fine. Fixed
with a patchedDependencies patch that probes PATH first (so npm and a global node-gyp are
untouched) then locates the node-gyp inside the host's npm. Proven in a throwaway copy with
node-gyp absent: bun install --frozen-lockfile exits 0 and require('node-pty') loads under
both node and bun. npm install was already broken here with EOVERRIDE before and after the
patch, and this repo has no package-lock.json, so the npm path was never the flow.
Phase 6 (Rust sidecar) is a no-go, with arithmetic. proxy.ts does string comparisons,
header lookups, one URL parse and one UUID nonce — no disk IO, no network IO, no body parsing. It
costs 15 µs per document request and 2.5 µs per API request, against a measured TTFB of
9.7 ms and 3.6 ms. A Rust sidecar would have to sit in front of Next and pay a 200–500 µs
loopback hop, so it would make every request ~0.3 ms slower, add ~20 MB RSS next to a Next
process that must stay running, double the deploy pipeline across three instances, and put the
CSP nonce and split-origin rewrite parity at risk — where a one-byte divergence from what Next
expects breaks hydration under strict-dynamic. The proxy belongs where it is.
Also fixed: the release gate blocks a push on any Turbopack build warning, and one appeared
after the route extraction — lib/camoufox/http.ts lost its /* turbopackIgnore: true */
annotation, which is load-bearing rather than decorative: PASSWD_FILE comes from the
environment, so without it Turbopack traces the whole project. Four other files still carried the
annotation, so the convention existed and this one had simply fallen out of it.
Evidence. typecheck 0, lint 0, check-cycles 2174 files / 0 cycles, check-architecture
healthy at 43/43 with nonMcpMcpImports 0, check-docs current, check-contrast 0 fail,
check-instance-literals 3411 files, audit --strict clean, full vitest
876 files / 5721 tests passed, verify-build.sh exit 0 with all release browser journeys
green. A 12-gate runner (scripts/gates-12.sh) now reports each check on one line so a push
decision does not require reading an 1800-line log.
2026-10-29: Perceived-performance gate, and the migration numbers it retracted
Before this, the only performance claims in the repo were bundle bytes from build output and a
browser journey that asserted absence of heavy engines. Neither could answer "did it get
slower", so a Next → Svelte/Bun/Rust proposal was resting on opinions. docs/MSO-MIGRATION.md
recorded a baseline for it; then the gate that was supposed to make that baseline reproducible
measured the page properly and contradicted it.
Five numbers in the first pass were wrong, and each one had a failure mode worth keeping:
- The throttle was set to 200 kbps down, which is Lighthouse's Slow 3G, not Slow 4G. At that rate the ~900 KB shell needs ~37 s to arrive, so the run measured the network and reported an FCP of 7.6 s.
- The wait selector was
#main-content, which exists in the server-rendered skeleton. The run therefore scored an 82-node pre-hydration frame and called it the shell. data-shellismacoson desktop andioson mobile; a hardcodedmacosmade the mobile run wait until timeout.- LCP lands ~3 s in, so a "settle when nothing changed for 1 s" loop exited at ~1.2 s and reported
lcpMs: null. - TBT was reported as the raw sum of long-task durations. TBT is
Σ max(0, duration − 50 ms). The corrected numbers are roughly a third of the retracted ones.
Recorded honestly: the earlier claim of desktop 443 ms / mobile 553 ms TBT was not a
measurement, it was an arithmetic error. Slow 4G + 4× CPU gives 164 ms desktop / 132 ms
mobile, against the 150 ms target the migration was supposed to reach. Desktop is within
10 % of it and mobile already beats it — before any migration. Attribution puts ~280 ms of
~355 ms of long-task self time on the react-dom chunk, but TBT that low means most of that work
overlaps idle rather than blocking input. What is actually still slow is LCP 3.1 s, and that
is first paint (CSS + the wallpaper artwork), which a framework swap does not change.
docs/MSO-MIGRATION.md §3 now sequences the cheap LCP work ahead of any rewrite, and its gate
criterion gates LCP instead of TBT.
Three more traps the gate had to absorb, all found by running it rather than reasoning about it:
a first cold load per session pays disk-cache misses for the whole shell and measured TBT 418 ms
against 164 ms warm, so one warm-up boot is discarded or CI flakes on every fresh runner; a null
tbtMs must be a violation, not a skip, because a painted shell with no attributable long
task means the probe broke, and passing it turns the gate off exactly when instrumentation
fails; and browser-measured first-load bytes must not be gated a second time, because they count
deferred chunks and move, while check-bundle.mjs already gates gzip bytes deterministically
from build output.
Shipped: perf-probe (cold load, Slow 4G + 4× CPU), check-perf (the gate), perf-longtasks
(CDP trace → long task → owning script), perf-app-open (per-app open cost), plus
lib/perf-report (parse/check/format, 23 tests), lib/trace-longtasks (pure attribution,
testable without a browser) and lib/browser-metrics (one place for the TBT formula, the
shell-ready selector and the throttle profile). check-perf gates a 2× TBT blowup against
scripts/perf-baseline.json and fails on a missing measurement; the 150 ms / 2.5 s targets are
printed as advisory so the gate is not permanently red.
Evidence. typecheck 0, lint 0, check-cycles 2145 files / 0 cycles, check-architecture
exit 0 at 43/43 files-over-220, check-docs current, check-contrast 0 fail LIGHT+DARK,
check-instance-literals 3278 files, audit --strict clean at high/critical, full vitest
862 files / 5633 tests passed, out-of-tree build plus every mandatory release journey
passed. Median of 3 fixtures runs at 1c74603: desktop FCP 1180 / LCP 3222 / TBT 164 / 870 DOM
nodes / 942 KB first-load JS; mobile FCP 1166 / LCP 3054 / TBT 132 / 1165 DOM / 926 KB.
Per-app open at 4× CPU: Image Editor ~550–600 ms and ~600 ms of long task, Video Editor
~450–470 ms and ~300 ms, System Monitor ~230 ms, Terminal ~190 ms.
Follow-up the same day, because the gate contradicted the doc it was built for: the entry
above concluded that a framework swap could not help, on the belief that LCP was set by
first paint. bun run perf:hydration disproved that. The shell mounts client-side by design
(appshell/components/desktop.tsx: the surface depends on innerWidth, localStorage and
the wallpaper pref, so SSR would guess macOS and a phone would hydrate iOS), so SSR paints a
82-node skeleton and the real shell arrives only after ~940 KB of JS executes. The mark chain
is FCP ~1.2 s → last JS byte ~2.9–3.1 s → mount ~2.6–2.9 s → icons ~3.2–3.9 s → LCP
~3.2–4.0 s. Throttle controls separate the levers: Slow 4G at 1× CPU saves 644 ms and no
network limit saves 1516 ms, so network dominates and CPU is real but secondary. LCP is
therefore hydration-bound, i.e. gated by exactly the bundle a migration shrinks, and
docs/MSO-MIGRATION.md §3 now gates on LCP instead of TBT with LCP 3.2–4.0 → ~2.5–2.9 s as
the realistic migration win. The lesson recorded in §6: reading the gate off the LCP element
tag is wrong, because the element that ends up largest can be painted arbitrarily late by
JavaScript.
2026-10-25: Agent transcript — one live row per turn, and owner-owned turn budgets
The interactive Agent printed an Agent work divider for every model round and a separate row
for every tool call, so a ten-round turn produced ten headers plus one row per call and pushed the
conversation off the screen. Progress now renders on a single live row below the transcript
(⠹ fs_search · 3/7 tools · 12s), repainted in place with the composer's own cursor primitives,
with one Agent work section per turn, a spinner while the first token is in flight, and a compact
receipt at the end (3 tools · all ok · 8s). Async Local Agent traffic suspends and repaints the
row, so a foreign write never lands inside it. Non-TTY stdout keeps the previous discrete lines, so
pipes, CI and the PTY smoke harness never receive cursor control.
The hard caps that ended work with turn limit reached are now owner settings instead of code
constants: OS_AGENT_MAX_ROUNDS (10 -> 1000 rounds per interactive turn),
OS_ASSISTANT_MAX_TURNS, OS_SUBAGENT_ABSOLUTE_MAX_TURNS, OS_SUBAGENT_DEFAULT_TURNS,
OS_SUBAGENT_MAX_TIMEOUT_MS, OS_AGENT_PROFILE_MAX_TURNS and
OS_AGENT_PROFILE_MAX_TOOL_CALLS. Defaults are the historical values, so behaviour only moves
where an operator sets the knob, and intEnv is exported from session-policy instead of copied
per caller.
A settings follow-up rides along: UpdateSection.start() marked the run as "seen running" before
the POST resolved, so a refused update was still graded from the log and a previous attempt's
UPDATE OK produced a success banner for an update that never ran. The flag is now set only after
a started response.
Evidence. typecheck 0, lint 0, check-cycles 2138 files / 0 cycles, check-architecture
exit 0 at 43/43 files-over-220, check-docs current, gen-comparison --check current,
check-contrast 0 fail, full vitest 852 files / 5535 tests passed. A real PTY run of
mso --yolo agent produced one Agent work section, 736 in-place repaints and the receipt
3 tools · all ok · 8s.
2026-10-22: CodeQL follow-up — the taint, not the temp path
The previous entry closed the symlink/TOCTOU concern but not js/http-to-file-access: the icon
value still descended from the request into JSON.stringify at the write sink. Two honest fixes,
verified against CodeQL 2.27.3 locally with the same two queries CI runs.
js/http-to-file-access (lib/auth/account-profile.ts). Option 2: the JSON shape is
unchanged, and the value written is now rebuilt rather than carried. libraryIcon validates with
LIBRARY_ICON, then reconstructs prefix + tint from the validated capture groups via
copyCodeUnits (now exported from account-profile-model.ts) instead of returning row.value.
imageIcon already rebuilt src from a validated kind prefix plus a fresh encodeBase64 of a
copied Buffer; the library branch was the one still holding request text. CodeQL reports zero
results for both js/http-to-file-access and js/file-system-race on a database built from this
tree. No suppression comment, no dismissal, no .github/codeql filter, no format change.
js/file-system-race (lib/auth/account-profile.test.ts). The staging test used
fs.stat(file) and then fs.readFile(file) on the same path. It now opens one read handle and
takes both the mode from handle.stat() and the content from handle.readFile(), so there is no
check-then-use pair on a path. The canary is still asserted byte-identical, the published store
still parses to the expected profile, the mode is still 0o600, and the only sibling is the
pre-planted canary.
Backward compatibility. No on-disk format change. Two tests cover old files explicitly:
parses a store file written before the library icon type existed writes a preset-only JSON and an
image data: JSON directly and asserts both still parse; rebuilds the stored icon from validated primitives so client bytes never reach the file unchanged proves a non-canonical base64 URL is
stored in its re-encoded form and a kind/magic mismatch is refused with the old bytes untouched.
Evidence. typecheck 0, lint 0, targeted vitest 9/9 (exit 0), coverage 836 files /
5389 tests (exit 0), check-architecture.mjs exit 0, audit:strict exit 0 printing
clean at high/critical, local CodeQL result count 0.
2026-10-22: CI-green fixes — unpredictable atomic profile writes and a bounded, honest registry probe
Two independent failures on main (c54422e4), both fixed at the authoritative layer.
CodeQL #190 — js/http-to-file-access at lib/auth/account-profile.ts:149. persist() staged
the profile at ${file}.${pid}.tmp and used a non-exclusive writeFile, so a pre-planted file or
symlink at that predictable path could be followed and truncated with client-derived icon bytes.
The staging name now carries randomBytes(8) and the write passes flag: "wx" (exclusive create,
fails instead of following), keeping mode: 0o600, the 0o700 mkdir and the atomic rename
publish. A write/publication failure unlinks the temp path best-effort and rethrows as
AccountProfileError("invalid"); readAccountProfile/cleanAccountIcon and the image allowlist
are unchanged. This matches the pattern already used by lib/host/fs-upload.ts,
lib/host/fs-upload-guarded.ts and scripts/orca/private-store.mjs. Regression tests prove the
old predictable path is never truncated, the store is 0600, no staging siblings survive, and
concurrent writeAccountProfile calls serialize to one untorn profile.
Verify — audit: registry timed out after 15s; INCOMPLETE (strict gate failed). The gate is
scripts/audit.mjs (wired as audit:strict for CI, scripts/gates.sh, pr-preflight.sh, and
security-ultimate.sh). Its single 15-second probe turned a cold-runner handshake into a red
build with no vulnerability to report. It is now 30s per attempt, 3 attempts (first + 2 retries)
with 2s/4s backoff inside a 90s total budget — worst case still far inside the 30-minute job.
Exhausting the budget fails closed with registry unreachable (...), which cannot be read as
"advisories found". A silent registry may reuse prior evidence only when a receipt for this exact
bun.lock digest is under 7 days old; otherwise the job stays red. Exit-code contract is intact
(0 clean, 1 advisories, 2 incomplete).
2026-10-22: Updates check the merge before refusing, and the foundation boundary is written down
A dirty or diverged checkout used to get a bare refusal, leaving a user who simply wanted the
newest MSO with a stash-or-nothing choice. lib/host/update-conflict.ts now runs a READ-ONLY
preflight with git merge-tree --write-tree --name-only --no-messages HEAD <target> (git 2.43):
that computes the merge in memory, so no index, worktree, stash or HEAD is touched, and only
throwaway tree objects land in .git/objects. It reports conflicted (what git cannot merge),
carried (the user's committed + uncommitted + untracked files since the merge base) and
overlap (carried ∩ incoming). safe requires a clean merge-tree exit AND no overlap, because
merge-tree reads commits and cannot prove anything about uncommitted work.
blockingReason keeps its string | null contract; the new updateRefusal returns the same
sentence plus conflict, so UpdateStatus.conflict reaches Settings only when the checkout is
dirty or diverged and GET /sys/update stays a read. Settings renders the exact file list and
copies updateConflictPrompt() — a plain-text instruction that names the target/current commit
and every path, tells an agent to preserve ~/.mso and local commits, and forbids
git push --force, git reset --hard and deleting user files. docs/ARCHITECTURE.md now states
the foundation-vs-user-customizations boundary the user requires, with the before-not-after rule.
Coverage: 9 real-git tests in lib/host/update-conflict.test.ts (mkdtemp 0700 fixture) prove the
three preflight states, the no-mutation invariant (HEAD, status --porcelain, ls-files,
stash list identical before/after) and prompt contents, plus extended decision/status tests.
The custom PWA install pill is gone (app/install-prompt.tsx deleted); RegisterSW, the
manifest and the service worker are untouched, so installability stays a browser-menu action.
2026-10-21: Shell-app domain provisioning (phase 1, worker B)
New lib/surfaces/app-domain-provision.ts provisions a public hostname for a shell-app entry:
loopback probe → DNS write → route → verify, persisting every phase in an owner-only
~/.mso/private/shell-app-domains.json (0600/0700, O_NOFOLLOW, uid-checked, locked) so a failed
run resumes at the phase it reached instead of restarting from pending. Hostnames equal to,
domain-matching, or containing the cockpit name, names inside OS_SESSION_COOKIE_DOMAIN, and
anything externalSurfaceSharesSession blocks are rejected with a precise error — never
substituted. Owner-only POST/GET /api/v1/shell-apps/[id]/domain mirror the existing shell-app
gate order, rate limit, Cache-Control: no-store, private and audit trail. New CLI verbs
mso mapp shell-domain <id> and mso mapp shell-domain-save <id> <JSON|@file> keep every route
reachable from a shell.
Contract 1 is lib/infra/managed-domain-providers.ts; provisioning imports its three boundary
functions directly, so there is no injection seam in the shipped composition root. The genuine
provider_unavailable case is a configured provider with no stored credentials, which that
module raises itself. lib/contracts/app-domain.ts is the single server-side spelling of the
provider union and record shape; the browser copy in
frontend/slices/app-store/lib/app-domain.ts mirrors it and a parity test fails on drift.
2026-10-21: mso ai shows the reply text, not the SSE frames
mso ai sent the right OaMsg text after #133, but it still printed the raw response body, so an owner read event: delta / data: "…" frames instead of an answer. scripts/mso-sse-text.mjs now consumes that stream: delta frames become stdout text, an error frame fails the turn with a non-zero exit, unknown events stay silent, and a non-SSE or empty body can no longer pass as a successful empty answer. The verb pipes through the reader; the entrypoint header, generated docs/CLI.md and the runtime help all say so.
Coverage pins both halves of the boundary instead of only the memory helper: app/api/assistant/normalize-content.test.ts asserts the route turns an OpenAI-shaped {content} into {text} before recall and the streamer, and keeps streaming when neither shape carries a prompt; scripts/mso-ai-cli-contract.test.ts asserts the verb posts text and renders through the reader; scripts/mso-sse-text.test.ts covers delta concatenation, JSON escapes, CRLF framing, unknown events, error frames and non-SSE or empty bodies.
Evidence at the committed candidate: 13/13 targeted tests, tsc --noEmit, eslint . --max-warnings=0, architecture (entrypoint 203/220), cycles, docs and generated-CLI-docs checks all PASS; a live one-turn call through the worktree CLI printed a multi-line reply and exited 0. bun run pr:local and bun run pr:security are BLOCKED on this host (no zip, no Docker, no browser fixtures), so the PR stays Draft until hosted checks supply that evidence.
provider union and record shape; the browser copy in
frontend/slices/app-store/lib/app-domain.ts mirrors it and a parity test fails on drift.
2026-10-21: Shell-app domain provisioning (phase 1, worker B)
New lib/surfaces/app-domain-provision.ts provisions a public hostname for a shell-app entry:
loopback probe → DNS write → route → verify, persisting every phase in an owner-only
~/.mso/private/shell-app-domains.json (0600/0700, O_NOFOLLOW, uid-checked, locked) so a failed
run resumes at the phase it reached instead of restarting from pending. Hostnames equal to,
domain-matching, or containing the cockpit name, names inside OS_SESSION_COOKIE_DOMAIN, and
anything externalSurfaceSharesSession blocks are rejected with a precise error — never
substituted. Owner-only POST/GET /api/v1/shell-apps/[id]/domain mirror the existing shell-app
gate order, rate limit, Cache-Control: no-store, private and audit trail. New CLI verbs
mso mapp shell-domain <id> and mso mapp shell-domain-save <id> <JSON|@file> keep every route
reachable from a shell.
Contract 1 is lib/infra/managed-domain-providers.ts; provisioning imports its three boundary
functions directly, so there is no injection seam in the shipped composition root. The genuine
provider_unavailable case is a configured provider with no stored credentials, which that
module raises itself. lib/contracts/app-domain.ts is the single server-side spelling of the
provider union and record shape; the browser copy in
frontend/slices/app-store/lib/app-domain.ts mirrors it and a parity test fails on drift.
2026-10-19: Orca bridge corrective checkpoint (local development candidate)
Local candidate on feat/orca-web-20261019. Not merged, released, or deployed. This pass fixes
fail-open defects in the earlier Checkpoint 3 readiness/pairing/session/UI bridge; the runtime
installer/lifecycle slice (scripts/orca) is owned separately and untouched here.
- Readiness is now fail closed (
lib/managed-apps/orca-readiness.ts): requires the exactorca_server_readyschema-1 tag,health.buildVersion1.4.230 (anartifactVersioncannot override it), pinned Node 24.21.0 ABI 137, live terminal daemon,wsloopback bound endpoint on the managed port, exact configuredwssadvertised endpoint, and explicit runtime pairing. - Mandatory identity receipt + process identity (
lib/managed-apps/orca-process-identity.ts):runtime-identity.jsonis required; PID/startTicks/UID/exe/cmdline must match via/proc(never environ). Missing/reused/foreign/unreadable/EPERM identity denies. A real disposable same-task node process is exercised in tests; the test runner's PID is refused. - Symlink-proof bounded private reads (
lib/managed-apps/orca-private-fs.ts): rejects symlinked ancestors/leaves, opensO_NOFOLLOW, bounds size before reading, re-checks identity, and never touches the owner's personal~/.orca. InvalidORCA_HOMEfails closed instead of silently falling back. - Strict pairing + canonical web client (
lib/managed-apps/orca-pairing.ts): explicit runtime scope only, exact trusted WSS endpoint with no relay/userinfo/path/query, and a server-constructed…/web-index.html#pairing=<encoded>fragment. Upstream grants are not certified; arbitrarywebClientUrlis never trusted. - Session route returns
no-storeon every outcome and 503 with a safe reason when readiness is missing (app/api/v1/managed-apps/[id]/session/route.test.ts). - UI authorization pipeline (
frontend/slices/managed-apps/app-authorization.ts,feature-app.tsx): Orca-only URL override, stale-request abort, prior-authorization invalidation; tested with realResponse/AbortController. - Honest docs:
docs/ORCA-INTEGRATION.mdcorrected and classified indocs/README.md; no real browser/runtime/install verification is claimed.
2026-10-19: Orca web integration Checkpoint 3 (local development candidate)
Local development candidate on feat/orca-web-20261019. This is an in-progress worktree candidate, not merged to main, not released, and not deployed.
Scope implemented:
- Verified bootstrap JavaScript execution inside an isolated VM browser DOM sandbox (
lib/managed-apps/orca-bootstrap.test.ts), proving credential exchange, pairing fragment preservation in the hash, ticket removal, and error handling without query parameter leakage. - Enforced arbitrary-path
Sec-Fetch-Dest: serviceworkerrejection at the reverse proxy boundary without upstream invocation, and verified that dedicated/shared workers are forwarded only under live Operator authentication. - Server-only Orca private readiness parser and bridge (
lib/managed-apps/orca-readiness.ts), strictly enforcing fixed managed root (~/.local/share/mso/orcaorORCA_HOME), 0700/0600 file modes, 64KB size limit, no symlinks, process liveness check, version 1.4.230 check, port 6769 loopback bind, live terminal daemon state, and pairing offer invariants. - Upstream pairing offer decoder and validator (
lib/managed-apps/orca-pairing.ts) conforming to Orca v1.4.230 schema, validating same-origin WSS endpoint, runtime scope, and absence of desktop-control grants. - Session route bridge (
app/api/v1/managed-apps/[id]/session/route.ts) returning safe pairing payload{ origin, ticket, pairingUrl, webClientUrl, runtimeId }exclusively for live Operator sessions withCache-Control: no-store; rejecting unauthenticated or Viewer callers with 401 and unavailable Orca instances with 503. - Orca UI component and state tests (
frontend/slices/managed-apps/orca-ui.test.tsx), validating initial loading presentation, disabled installer wheninstallBackendsis empty, fragment resolution without query secrets, and rejection of Viewer roles without credential leakage. - Catalog configuration updated to repo-owned adapter path
scripts/managed-app-orcawithcommandProvesInstall: false, servicemso-orca.service, no generic container detection, default port 6769, health path/web-index.html, and state dirorca. - Added portable documentation
docs/ORCA-INTEGRATION.md.
2026-10-18: MSO deep QA stopped at the user's request
Work and active QA were stopped on 18 October 2026 at the user's explicit request. This is a progress checkpoint directly on main, not a release of the development candidate. Resume implementation, validation or deployment only after a new user instruction.
Repository and runtime: PR #127 reconciled the five unique laptop commits and is merged at 0cf5cf29caaef5ebfc0d8e73a96b06d9014c858e. The remote installation remains at 53fa602e48d422615cf5ee127b8dedf513226920 (CLI 0.2.23); the official updater has not been run for this QA candidate. The live checkout was preserved.
Committed development work: fix/deep-qa-contracts-20261018 is clean at 3cc4e04f5432cc23608753f94bbd63f142999991. The subsequent scanner-compatible, test-only fix is committed separately at 4742b6a508d9baeaffcaf5d711d9f87e8d871754 on test/auth-semgrep-portability-20261018, ready for integration. These development commits remain on the remote development host; they have not been pushed as a new PR or merged into official main. Existing worktrees and their commits were retained.
The audited scope covers shared contracts, manifest/registry/catalog identity, serialized private configuration writes and validation, window/Space/URL lifecycle, private Code/Image/Video drafts and save guards, stale session/registry reconciliation, consumer-owned menu logout, Dock/Launcher accessibility, passive update status, opaque native modal materials and layering, first-use hydration/setup context, privacy-lock isolation, host file metadata and screenshot-browser discovery. Generic shell composition keeps application/authentication ownership outside the core.
Independent fixture evidence, with provenance:
- Root build
58d1bc30: 78/78 safe route mounts for 26 applications at three viewport sizes, 11/11 shell checks, both Settings Axe scans clean, no page/5xx errors or horizontal overflow. This is route coverage, not a claim of every service workflow being complete. - The same build passed all 11 durable media outcomes, including draft/history across responsive remount, failed-save/retry with a real PNG write, real video import/split/trim/export and decoded WebM, empty New project/Undo, and popup/Cancel/focus behavior with an active update notice. Actual modal/popup/tooltip/lock layers were inspected in the browser.
- Privacy-lock ancestry
bba93e3b: independent delayed-chunk, repeated desktop/mobile parent-modal replacement, native pointer/keyboard/accessibility isolation, draft/focus restoration and Viewer authority revocation passed. - Production source
33bded1b: all ten native shell/theme Axe cases passed across macOS, iOS, Windows, Android and Dashboard, with actual shell identities, opaque surfaces, persisted Settings theme selection, synchronized palette changes and retained entry motion. Fresh/resumed/skipped onboarding, a real persisted receipt, reload, keyboard and role-denial checks passed. Subsequent candidate changes are tests/documentation only.
Final gate state at stop:
| Check | Exact evidence | Status |
|---|---|---|
| Production build and bundle | 3cc4e04f: entry 156.5 KiB gzip; CSS 30,713/30,720 bytes |
PASS |
| Unit suite | 3cc4e04f: 5,120/5,120 tests, 816 files |
PASS |
| Typecheck, lint, architecture/docs/cycles, contrast and strict dependency audit | Completed within the 3cc4e04f local gate |
PASS |
Complete bun run pr:local |
Stopped by the user during the isolated build/browser stage; process exited 143 | CANCELED; not PASS |
Complete bun run pr:security |
3cc4e04f: zero findings but strict Semgrep rejected a TypeScript type expression in the new session test |
FAIL; not PASS |
| Targeted scanner correction | 4742b6a5: equivalent type-only namespace syntax; same pinned image/rules; author and independent validator both observed exit 0, no parser errors/findings; old source reproduced exit 3 |
Targeted PASS; full-repo rerun pending |
| Targeted auth suite on scanner correction | 37/37 auth tests, including six actual-provider lifecycle cases; typecheck/lint/docs passed | PASS |
| Final normal hooked push, new Draft PR, hosted checks/native CodeQL/review threads | Not performed for the development candidate | PENDING |
| Official update, doctor and independent live-runtime verification | Not performed | PENDING |
The earlier 267ccd40 full unit run had two test-only failures (an undocumented E2E artifact variable and an assertion tied to old promise spelling). Both were corrected before the 5,120-test pass above. The scanner fix preserves all behavioral assertions; no image, ignore rule, threshold or scanner policy was relaxed. Independent fixture acceptance does not replace the missing final gates.
Preservation and boundaries: 47 dirty legacy experiment files across three older worktrees and alternative OAuth refs were preserved privately; archived material is not represented as committed, PR'd or released. Real third-party provider consent, paid transactions and persistent browser profiles were not exercised. Optional Camoufox is not installed on the remote host. The design comparison uses primary documentation for macOS, Puter, OS.js, daedalOS, Windows Snap and GNOME as of 18 October, without claiming future November changes or measured competitor superiority. Landing/demo metadata for mso.manef.dev was prepared; DNS/hosting was not changed. Lab/bundle checks are not a field-performance or human-usability study.
Resume checklist: integrate the ready test-only commit; regenerate the changelog; build the final clean HEAD before running full pr:local and pr:security; perform the normal hooked push and Draft PR; inspect all latest-head hosted checks, actual native CodeQL alerts and review threads before readiness/merge; then use the official remote mso update lifecycle and independently verify exact main/build identity, replacement PID, served assets, doctor and native-shell health. No continuation or deployment is scheduled by this checkpoint.
2026-10-18: Isolate the real PTY integration fixture from owner shell state
Two complete candidate gates passed before a later concurrent full run observed no PTY exit callback within the unchanged eight-second close deadline. Command execution and replay had succeeded; the exact native scheduling cause was not established. The standalone test passed under the same host load.
The real integration fixture now declares a private executable shell wrapper through scoped SHELL, preserves the production login-shell arguments, and runs actual Bash with --noprofile --norc. Private history and readline files replace the owner's shell startup, history and input configuration. A finally block detaches listeners, closes any remaining fixture PTY, restores the scoped environment and removes temporary files. Production PTY code, signal behavior, real echo/replay/kill/exit/idempotence assertions, and the original eight-second/twenty-second time limits are unchanged.
Focused validation includes ten repeated real-PTY runs and nine ownership/limit/stream tests. Full preflight, strict security and normal hooked publication must still pass on the committed candidate; earlier successful gates do not certify this new head.
2026-10-18: Reconcile preserved laptop changes onto current main for review
The laptop-only observation/connection diagnostics, agent PR-readiness policy, and hidden local password setup were preserved as five original commits and replayed onto 53fa602e. The source changes remain a review candidate in an isolated branch; they have not been merged or deployed. Existing main already contains the custom-provider model-discovery work, which is excluded from this candidate.
History-only conflicts retain both progress records. The local-maintenance extraction keeps main's shared help-before-credentials helper, including that helper in the password fixture. New word-boundary compaction tests now exercise a non-overridden tool at main's existing 24-character limit and explicitly preserve the workflow_start first-call override. No profile budget or production ownership guard is relaxed.
Candidate checks so far: 136 focused tests across 16 files, typecheck, zero-warning lint, architecture ratchets, current-reference docs, generated MCP catalog and generated CLI reference pass. Full PR, security and hosted checks remain separate gates; this entry does not claim merge or release readiness.
The first full local run executed 4,946 tests with 4,945 passing; its sole failure was the existing Termux assertion requiring group/other execute bits under the mandated private umask. The candidate adopts the already-reviewed owner-executable assertion from the concurrent foundation candidate. The pinned strict Semgrep run reported no findings but failed partial parsing of Bash's combined read/write terminal descriptor. Equivalent separate read/write descriptors retain hidden prompts and terminal-only input while allowing complete parsing; the existing real-PTY regression verifies echo suppression, confirmation and cancellation. Scanner rules and production guards remain unchanged.
The preserved public observation contract is versioned as toolset 2026.10.18.3, with the generated catalog refreshed. The concurrent foundation candidate owns .2; the two independent PRs still require normal version/catalog reconciliation at integration. Tool names, scopes and counts remain unchanged. Pinned strict Semgrep now parses all selected lines with zero findings, and pinned warning-level ShellCheck passes on the CLI repair; hosted checks must verify the eventual pushed SHA.
2026-10-18: Repair model-discovery findings and separate CodeQL from historical Scorecard posture
The main push at 94c133a2aa6bcb8e54f39286d9b4993a2f47855a completed its CodeQL analysis, then failed the open-alert gate on four CodeQL findings and Scorecard SAST alert #137. The model-discovery route already injected the pinned provider transport, but its shared helper exposed a raw-fetch default. The helper now owns the mandatory SSRF/DNS-pinned transport. Invalid credentials, provider response bodies and unexpected transport errors cannot be returned as diagnostic text containing API keys. Rejected and oversized responses cancel their bodies. The domain environment regression now checks final content and file permissions through one opened descriptor while retaining its idempotence assertion.
CodeQL's post-upload gate now selects only CodeQL alerts through GitHub's tool filter and fails closed if the response violates that filter. The separate security inventory still checks every tool and fails on any open finding. Regression coverage explicitly proves that a Scorecard finding still fails the combined inventory. No alert was dismissed, no scanner rule was excluded and no security threshold was lowered.
Scorecard #137 is an accurate historical process finding: PR #123 was merged with a failed native CodeQL check reporting two new high-severity findings, although its Actions analysis job succeeded. The pinned Scorecard v5.5.0 examines recent commits associated with merged PRs and requires successful native SAST checks for their recorded PR heads. Rescanning fixed main code does not change the historical PR head. The Scorecard workflow therefore remains unchanged, and a clean current CodeQL result must not be described as a clean all-tool inventory while #137 remains open. Merge review must inspect the native CodeQL result as well as the Actions job.
Local candidate verification: 74 focused tests across six files pass, including real URL/DNS-guard execution with intercepted sockets, address pinning, redirect refusal, malformed keys, response cancellation and strict inventory failure cases. Typecheck, zero-warning lint, repository contract checks and the strict high/critical dependency audit pass. Hosted CI remains the full coverage/build/browser gate because this isolated development environment has no Docker daemon for the mandatory Forge fixture. MSO MCP returned an internal error during target discovery, so this entry records repository work rather than a runtime deployment.
The first hosted candidate passed both CodeQL Actions analyses, the native GitHub CodeQL check and the branch's all-tool inventory with zero open findings. Its push CI exposed a separate workflow status race: a descriptor could return the previous running receipt after execution had saved the final receipt and removed its pending promise. Status now captures that completion promise before reading the receipt, preserving the bounded wait and final reread. Two deterministic regressions reproduce the old stale result for failed and completed runs. All 14 related tests now pass, including the existing execution, idempotence and live-authority cases; typecheck, zero-warning lint and repository checks also pass. Full hosted CI must pass again on the revised candidate before merge.
2026-10-18: Implement the first three bounded Nakama journeys
Owner onboarding now advances from installation readiness to a selected project and a saved, read-only Workflow receipt. Its first action uses a fixed graph and exact graph revision; it stores the attempt identity before dispatch, reconciles lost responses and reopens the existing receipt after reload. Optional model checks disclose their cost, while the initial project action needs no inference. Viewer and Operator devices can inspect readiness without receiving Owner controls. The backup link describes the actual browser and memory restore surfaces; it does not imply a full installation restore.
Saved Owner profiles now have a private server store, revision history, stale-write protection, same-device cloning, default selection and enable/disable controls in Alfa and the CLI. A foreground run binds the saved provider/model and exact enabled revision, narrows execution to nine reviewed read tools, and uses the canonical capability kernel. Live authority is checked around model and tool work and again after session persistence before returning a result. The shared loop retains existing subagent behavior while profile runs have six turns, sixteen tools and sixty seconds. This establishes a device-owned configuration lifecycle, not human-account, organization or process isolation; the remaining assignment and worker requirements stay explicit in AGENT-PROFILES.md.
Workflow schedules now support explicit-offset one-shot timestamps with a required run_once missed-tick policy. A private durable intent precedes dispatch and survives receipt deletion or pruning; equivalent timestamp spellings cannot replay the same occurrence. Ancestor, file and parent-directory sync failures block dispatch, and an uncertain post-rename intent requires reconciliation. Existing recurring fields remain readable and inert after old editor mode changes; selected-mode validation still applies. WORKFLOW-SCHEDULES.md documents cron day matching, timezone behavior and the limits of local claims and physical durability evidence.
The implementation map records five partial requirement groups and 59 pending groups, with no group marked complete. All 64 frozen groups, 24 packages, eight stages, 30 acceptance journeys and 69 derived compatibility variants remain in scope. The new browser journeys use their own synthetic stores because their real persisted sessions would otherwise contaminate the existing session-monitor pagination fixture.
Integration preserves the current upstream session-turn runner, provider usage accounting, thread search/rename, skills cache and compact fs_stat catalog. Two UI lint failures initially prevented the combined gate: the chat controller exceeded the line limit, and the thread drawer synchronously reset state in an effect. Upstream subsequently resolved both with useTurnUsage and a drawer open-transition reset. This candidate adopts those upstream implementations and its service-owned update recovery fix; the temporary duplicate presentation extraction is removed.
PR verification also exposed a sourced CLI usage variable without its module-level fallback and four test-only inline import types that the pinned Semgrep parser could not read. The CLI now follows neighboring modules' explicit fallback, and named type aliases preserve the exact mocks and assertions. Actual ShellCheck 0.11.0 and a complete Semgrep 1.174.0 strict scan pass after these repairs; no scanner rules or exclusions were relaxed.
The subsequent managed-domain merge exposed additional integration gates: operator-specific handoff paths, an unchecked CLI directory change, and test/Bash syntax that the pinned parser could not read. The paths are portable, domain dispatch stops when its checkout cannot be entered, and equivalent type aliases and multiline case arms preserve behavior. The heartbeat fixture now includes the extracted named-config helper. Interrupted connector recovery accepts the two exact failure phases of its immediate-exit fixture while retaining state, liveness and retry checks, and also verifies the pending receipt is unchanged.
CodeQL also identified a production pathname reread in the new named-gateway helper. Its final comparison now reuses the initial no-follow, nonblocking descriptor reader, checks device/inode/mode before reading bytes, and preserves content comparison plus the existing durable replacement. Deterministic regressions cover a symlink swap after open and rejection of a different inode before reading. Gateway locks still coordinate MSO writers rather than provide atomic compare-and-swap with external editors. The separate custom domain-store filesystem-exclusion limitation remains recorded in the PR.
2026-10-18: Freeze the complete Nakama target and separate inventory from runtime proof
The approved v0.1 draft spans 64 requirement groups, 24 packages, eight stages and 30 acceptance journeys. The immutable snapshot preserves all original contracts and variants; the generated current reference reads a separate implementation map so progress cannot silently reduce the target. Source receipts identify all 100 distinct referenced files at the pinned Nakama and MSO commits. File identity proves source availability, not runtime behavior.
The repository checks now validate the snapshot digest, exact requirement mappings, source identities and generated reference. A separate full-parity candidate gate requires clean HEAD, regular tracked source/test blobs, complete acceptance and compatibility records, all eight completion dimensions and six passing gates. Every receipt is bound to the candidate and hashed artifact bytes. A complete manifest cannot establish that its statements are true: release reviewers must inspect real runtime/provider evidence. Pending or partial scope keeps that release gate blocked.
CLI help previously loaded HTTP credentials and attempted to create a private cookie jar before printing recovery guidance. Help now reads the existing entrypoint header before credential loading; grouped usage shares that helper and the offline-update fixture copies it. Regression tests use an executable synthetic env file and unusable private storage to prove help stays available without either side effect.
2026-10-18c: A service-owned listener no longer dead-ends an update; Alfa lint restored
Two follow-ups after the agent-surface batch.
Service-active updates. An interrupted update could leave a gateway restore inventory naming an origin
that this checkout's own mso.service now serves; the quiesce step then failed closed ("a loopback MSO
runtime is active but is not gateway-owned") and every retry failed identically. The service-active quiesce
path now reports runtime: service-owned when gateway_service_owns_local_listener proves the healthy
listener belongs to this checkout's own active unit — that listener is not a fallback runtime, the service
lifecycle keeps it, and scripts/self-update.sh replaces it by signalling its same-UID MainPID, so there is
nothing to quiesce. The offline preflight (runtime-assert-update-safe) keeps the strict form, and any
listener not proven to be this checkout's unit still fails closed. Regressions:
scripts/mso-gateway-service-owned.test.ts plus a service-owned case in scripts/mso-service-update.test.ts.
Lint. The batch above shipped two bun run lint failures that neither a --no-verify push nor the
build-only verify stage catches: a react-hooks/set-state-in-effect error in the saved-chat drawer and a
max-lines breach in chat-panel.tsx (239 counted lines). The drawer now resets with a render-time state
adjustment (its History button opens the sheet without routing through onOpenChange), and the token-usage
state moved into a new useTurnUsage hook, returning chat-panel.tsx to 217 counted lines.
docs/CHANGELOG.md was regenerated.
2026-10-18b: fs_stat returns, paid for by a tighter ChatGPT description cap
The read-scope fs_stat tool (true size/mtime without exec_run or reading binary content) was reverted
earlier today because its descriptor pushed the complete ChatGPT profile to 94,584 bytes, past the in-repo
92 KiB gate asserted in lib/mcp/chatgpt-profile.test.ts. The established way to admit a tool is to
compact the profile rather than raise the gate (see 2026-10-09), so lib/mcp/tool-contract.ts now caps the
compact one-line descriptions at 24 characters (was 30) and keeps an explicit COMPACT_DESCRIPTIONS
override for workflow_start ("First call: multi-step") so the first-call rule survives the tighter cut;
skills_search's compact description was shortened so mso-agent-bootstrap stays intact. The complete
profile is now 93,877 bytes with the new tool (331 bytes of headroom under 92 KiB), the toolset moves to
2026.10.18.1 (119 model tools) with a regenerated catalog, and fs_stat's guarded statReadableMeta host
facade plus its parity MCP_ONLY entry are restored. The documented scanner budget is 96 KiB
(docs/CHATGPT-PLUGIN.md); the in-repo gate stays deliberately stricter at 92 KiB, and only the character cap
changed — names, schemas, scopes and safety semantics are unchanged.
2026-10-18: Four agent-surface improvements, a CLI verb, and one benchmark that said "no change"
A parallel agent run (one coordinator, disposable worktrees under ~/.cache/mso-worktrees/mso-*, each worker
owning a disjoint file set) landed four independent improvements to the agent surface plus one CLI verb, plus
one benchmark run that correctly produced no code. Everything below was reviewed as a diff, merged to main,
and gated.
/api/skills is cached now. lib/skills/catalog-ttl.ts is a value-level memo (createCatalogTtl, 15 s
default, injected clock, single-flight) wired into the list branch of app/api/skills/route.ts. The Cockpit and
skills.list tool calls stop re-walking every skill root per turn. The ?name= branch stays uncached (a stale
name lookup would be a trust bug), ?refresh=1 forces a re-walk, and the scan/continuation report passes
through byte-identical so scan.truncated still means incomplete-not-absent. This closes the one gap the
assistant contract named.
A read-scope fs_stat tool was prototyped and then reverted. External MCP clients had no way to learn a
file's true size or mtime without exec_run or reading binary content (fs_list reports size 0 by design),
so a guarded statReadableMeta host facade and an fs_stat declaration were added — but the added descriptor
pushed the complete ChatGPT profile to 94,584 bytes, past the in-repo 92 KiB budget gate asserted in
lib/mcp/chatgpt-profile.test.ts. That gate is deliberately stricter than the documented 96 KiB scanner budget
(docs/CHATGPT-PLUGIN.md), and MSO's established way to admit a tool is to compact the profile, not to raise
the gate. No compaction left the asserted compact descriptions intact at the required saving, so the change was
reverted rather than weakening the budget; the toolset returns to 2026.10.10.1 (118 model tools). Re-adding
fs_stat needs a profile-budget plan first (reclaim ~400 bytes, or an owner decision on the 92→94 KiB gate).
Alfa's saved-chat drawer is searchable and safe. It rendered updatedAt but never showed it, had no
search, could not rename, and deleted a chat with no confirmation. lib/ai/threads.ts gained renameThread
(atomic temp-file save), app/api/threads/route.ts gained an owner-gated PATCH { id, title } with the same
id validation the delete path uses, and the drawer filters, sorts, shows relative time, and gates delete
behind a confirm. Title persistence survives later turns instead of being re-derived from the first message.
Proactive agent turns are bindable to a durable session. This is the seam OpenDots-style "always-on"
agents needed. A graph agent node may now set sessionRef; lib/agent/session-turn.ts
(runDurableSessionTurn) resolves the same-owner session, runs the bounded turn through the existing local
session seam, serializes with an at-most-one execution lease so two turns cannot interleave history writes,
and persists the turn (history append + agent_turn audit event). Combined with the existing in-process
schedule trigger this needs no systemd timer, cron entry, or second scheduler, and lib/workflow/graph-authority.ts
is untouched — unattended authority is still web:*-only with a live device recheck.
Per-turn token usage is visible. Every provider stream already emitted usage on its done event and the
client threw it away. AgentTurn/AgentLoopResult now carry an optional ProviderUsage (additive only, so the
image editor that also calls runToolAgent is unaffected), accumulated across tool rounds with addProviderUsage,
and rendered per turn plus as a running thread total.
The new rename route needs a reachable CLI verb. bin/mso.test.ts requires every app/api (method, path)
to map to a named verb, so PATCH /api/threads added a jpatch transport helper and a threads rename <json>
verb, and docs/CLI.md was regenerated from the help text (the same change keeps docs/CLI.md fresh).
The cognitive-routing task produced no code, on purpose. The worker ran bun run bench:cognitive; all 17
gates passed (100% routing recall, 97.3% schema reduction, deterministic selection). Per the P7 #5 / P8 #6
closed-loop rule, a passing corpus is not evidence of a defect, so it reported the observed gate values instead
of inventing a speculative change.
2026-10-17: Make PR readiness auditable across MSO coding agents (candidate)
PR #123 showed four distinct blockers: two gateway tests failing during CI coverage, a ShellCheck SC2164 warning, strict Semgrep exiting 3 with zero findings, and two new CodeQL filesystem race alerts. Existing AGENTS.md and the pre-push scripts/gates.sh offered guidance but could not establish whether another AI surface had run it, and GitHub-only CodeQL cannot be proven before the PR exists.
The candidate adds an explicit agent-facing scripts/pr-preflight.sh and Bun commands pr:local, pr:security, pr:preflight. Local mode reuses the checked-in gates and strict audit rather than defining a weaker test suite; security mode reproduces pinned Semgrep/ShellCheck CI checks and fails closed when Docker is missing. A PR template and both agent manuals require exact-commit evidence, Draft state for unavailable checks, required GitHub CodeQL/review-thread clearance before marking ready, and no bypass. Automated contracts pin scanner parity. This is a candidate branch, not deployed or merged into main; GitHub-required checks and review resolution remain separate.
2026-10-17: Handoff the managed-domain CLI candidate for a new session
The owner explicitly requested a committed, pushed draft PR checkpoint and progress record before continuing in a new session. Implementation is preserved on agent/mso-103047d38625; the code commit is da3ce4f69dfcdcb44a26f4522ced653194ec6172, based on 89d61bb0d73b47047c67e51df9a6ee30351c8c3a. The task worktree is ~/.cache/mso-worktrees/mso-103047d38625; canonical remains ~/mso. Keep the draft separate from release integration until the remaining checks pass.
The implementation and operating guide are in docs/MANAGED-DOMAINS.md, scripts/mso-domain.ts, scripts/cli/managed-apps.sh, lib/managed-apps/domain-*, lib/infra/managed-domain* and the named-gateway helpers in scripts/lib/gateway-app-route*.sh / gateway-named-config.mjs. The earlier entry below records the design reasons. Setup persists a versioned private configuration, and enable/install/update/start/restart use its shared ingress-before-DNS lifecycle. The replacement connector must have its own registration evidence before the prior connector is retired; interrupted swaps use bounded identity-checked recovery.
Verification of the code commit:
- Typecheck and zero-warning ESLint passed.
bun run check, the strict high/critical dependency audit and generated-changelog check passed. - The targeted gateway run passed all 38 cases before the full run. Core configuration/store/probe/env, provider DNS/route, CLI and managed-app lifecycle regression groups also passed their targeted runs.
- Full
bun run verifycompleted its coverage run with 749 passing / 3 failing files; 4,604 passing / 5 failing tests (4,609 total). The overall verify gate failed and coverage completion is not a release pass. - Three failures in
lib/forge/forge.test.tsrequire a real accessible Docker daemon and the existingmso-forge-sandbox:node22-v1fixture image. No Docker executable, daemon socket or remote Docker host was available. After Docker is available, usebash scripts/provision-forge-sandbox.sh; do not replace these tests with mocks or skips. - Two candidate test issues remain:
scripts/mso-gateway-app-route-recovery.test.tsexpects the immediate-start failure text, while a loaded full run reaches the connection-registration failure instead; preserve the actual recovery/identity assertions when making that fixture deterministic.scripts/mso-heartbeat.test.tscopies a fixture checkout that lacks the newscripts/lib/gateway-named-config.mjs; update its fixture dependency inventory. - The isolated production build, zero-build-warning check, eager shell bundle budget and all mandatory browser journeys passed (build/E2E job exit 0). This includes release, native Integrations, native Google Integrations, server status, Assistant UX, deferred shell performance, macOS chrome and iOS lock checks on the code commit.
The MSO exec environment inherits NODE_ENV=production; unit/coverage verification must explicitly use NODE_ENV=test so production process-ownership guards correctly distinguish test fixtures. The successful baseline ZIP tests used real Info-ZIP 3.0 extracted to /tmp/mso-domain-toolchain.rZ3neG/root/usr/bin on this host; ensure a real zip executable is available when reproducing. Keep production build verification in scripts/verify-build.sh, which archives committed HEAD and never builds over the live checkout.
Operational state at handoff: the existing gateway-owned fallback runtime served the cockpit on loopback port 4005 and the public MSO hostname. This task did not deploy code, enable 9Router, write public DNS or apply tunnel routes. The selected Integrations user rahman and direct Cloudflare connection mso-domains now exist; their private setup form was opened, but the latest redacted connection query still reported the API token missing. Supply credentials through that private form, with Zone Read, DNS Edit and Cloudflare Tunnel Edit for the intended zone/account. The desired nested 9Router hostname also needs a certificate covering it; a CNAME alone does not establish working HTTPS.
Next session should first read this entry and the draft PR, resume the existing branch/worktree, fix the two fixture issues, provide Docker/Forge prerequisites and rerun the required gates. Then verify the saved Cloudflare connection, run domain setup preview and apply as documented, rebuild through the supported lifecycle, and run mso mapp enable 9router or mso domain ensure 9router --apply. This installation has no active mso.service; its supported runtime rebuild is mso update --rebuild. The previous entry below explains why the current ship finalizer cannot complete on this topology.
Evidence retained on the host: workflow dc617f85-a3c5-4d80-925b-37f1eeb36f95; full verify job 8eb2c590-0c0d-4775-ba25-f39d01f19b3d, log /tmp/mso-domain-verify-final.QG0zye; isolated build/E2E job 254d79b0-1475-42ab-9baf-bc85092f9450, log /tmp/mso-domain-build-final.WiH3Vo; check/strict-audit job 5706b638-f060-41a4-9b32-c7d6b5259e6c. Logs and job access are host/session evidence; the committed summary is the durable handoff record.
2026-10-17: Persist managed-app domains and provision them through the existing MSO gateway
The earlier app-host RFC described the hostname and login boundary, but enabling an application did not own a complete DNS lifecycle or leave durable evidence when setup stopped halfway through. mso domain setup now discovers the existing Cloudflare zone, account and named tunnel through a selected MSO Integration. Its public routing configuration, ownership ID, per-app progress, resource receipts and last error live in a private versioned store outside the checkout. Writes are atomic, retain the previous valid snapshot and serialize operations across processes; malformed or unsafe state fails visibly instead of becoming an empty configuration. The environment editor preserves unrelated values, validates the file before saving setup, and supports explicit repair after an interrupted write.
mso mapp enable <id> installs an absent managed app, waits for its existing job and starts it through the shared API. Successful install/update jobs and start/restart actions then use the same domain provisioner. Local runtime success remains visible if domain setup needs attention, while CLI exit 2 and persistent diagnostics identify that incomplete outcome. Status, doctor and preview commands do not create infrastructure; ensure --apply resumes the saved plan. Stopping or uninstalling an app does not silently delete its hostname.
Provisioning first checks the deployed MSO app-host authorization gate, the selected provider identity and exact-name DNS conflicts. It establishes the authenticated MSO ingress before publishing a CNAME. Remote tunnel updates preserve unrelated configuration; locally configured tunnels use only the existing MSO-owned named-gateway lifecycle. Conflicting foreign records/routes and unsafe Host overrides are refused. A matching record can be reused without taking ownership, and a lost DNS write response is resolved by rereading before retrying. App health and public HTTPS/authentication are checked separately before recording ready. The cockpit and app retain their existing separate, host-only authorization cookies.
Nested application names require a certificate covering those exact hosts. DNS creation is not presented as TLS success, and no paid certificate is purchased automatically. Current setup, repair and migration boundaries are documented in docs/MANAGED-DOMAINS.md; the old RFC is retained as historical context rather than an active setup recipe.
Verification on the inspected fallback-runtime host found no Docker executable, daemon socket or configured remote Docker host. The existing mandatory Tool Forge sandbox tests therefore remain an environment prerequisite for release; no live DNS, application installation or deployment is claimed from candidate-only checks.
2026-10-17: Repair observation workflows and show what connection checks actually verify
A hostname request could be treated as source mutation when its constraints said “do not modify files” or “jangan edit file.” The classifier now removes directly negated mutation verbs, including explicit coordinated lists, while retaining affirmative changes elsewhere and conservatively isolating ambiguous comma clauses. Declared affected paths also reach classification when there is no collision. This remains a bounded heuristic: the separate high-risk-domain policy is unchanged, and observational classification does not turn an exec grant into read-only shell access.
Compact clients now receive the exact workflow workspace, canonical project path, isolation policy and available base Git identity. File reads and optimistic writes gain only the exact workspace from the authenticated session's active workflow. Read tools pin that workspace only when a bounded filesystem read needs additional authority, so status and configured-root reads remain available when the workspace is missing. Concurrent reads share one pin; cleanup revokes additional authority before awaiting its closure, including detached continuations. The kernel clears inherited additional read authority before nested dispatch. Write and exec isolation still pin eagerly. Configured read roots, credential checks, descriptor validation and write boundaries remain in force.
Settings → MCP → Connection details now shows owner-only hostname, service user, runtime instance and an optional operator-declared environment from OS_INSTANCE_ENVIRONMENT. The environment is independent of NODE_ENV; a production build does not identify a production host. The public health response is unchanged. Connection checks record the observed origin, configured endpoint and time; health, HTTPS, MCP descriptor, OAuth challenge and metadata have separate evidence. Each request has an eight-second deadline and JSON has a 64 KiB limit. A changed or missing expected runtime identity prompts target verification. The selected external AI account and its cached tools stay unknown; a local discovery pass is not evidence that those client states are current.
When project discovery returns no matched rows, its recovery hint explains child-directory scanning and continuation, then points to exact configured-container-path inspection when that path matches the target. It does not rename root-project identities. Root enumeration needs a separate compatibility change because project IDs also key Vault storage, skill references and flow idempotency. LAUNCH-READINESS records that acceptance scope and corrects the earlier inference that an empty rulesets list meant unprotected main.
Compact tool descriptions now end at a word boundary where possible, preserving the existing character cap and full descriptor. The ChatGPT profile retains all 120 tools and serializes to 94,001 bytes, below the existing 92 KiB limit; schemas and budget limits are unchanged. Gateway child-process fixtures explicitly select test mode so an inherited production NODE_ENV does not change their expected behavior. The dedicated production listener-ownership regression still selects production mode explicitly.
Recorded WSL verification passed typecheck and lint, then ran 4,551 tests across 742 files: 4,548 passed and three Forge tests failed because the required Docker sandbox was unavailable. The full verify gate therefore remains failed; no Forge test is skipped or substituted. Focused filesystem/status verification passed 50 tests across five files, including workspace replacement, ownership, concurrent and nested calls, missing workspaces and pending pin cleanup. The connection browser journey is included in the existing mandatory release fixture at desktop, phone and landscape sizes. Build, required CI and live deployment evidence remain separate gates. These changes do not satisfy the off-host restore, fresh-user cohort, sustained SLO or dedicated agent-abuse readiness gates; Alpha/Developer Preview remains the release label.
2026-10-17: Deploying on a host with no mso.service, and why bun run ship cannot finalize there
The custom-endpoint discovery below reached main at 5fc9a5f, but bun run ship pushed and then failed its release finalizer: "could not safely quiesce gateway runtime at http://127.0.0.1:4005". Two independent environment mismatches, both in the handoff's assumptions:
scripts/ship-handoff.shfinalizes through asystemd-run --usertransient unit, and that unit's defaultPATH(/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:…) does not containnodeon this box (node lives in~/.local/binand~/.hermes/tools/…).scripts/mso-gateway runtime-stoptherefore exits instantly withmso gateway: missing dependency: node, before it can even inspect runtime ownership.- The same finalizer (
scripts/self-update.sh) restarts by signalling an activemso.serviceMainPID that hasRestart=always. This box has nomso.serviceat all; :4005 is a gateway-owned fallback runtime started outside systemd (cgroup/init.scope), so even a green quiesce would have dead-ended at "mso.service has no automatic restart policy".
The supported path for exactly this topology is the offline updater, which mso update selects whenever systemctl is-active mso.service is false: quiesce the fallback runtime → bun install → out-of-tree verify → in-place next build → write the deploy receipt → restore the fallback runtime. scripts/mso-update --rebuild deployed 5fc9a5f in place; GET /api/health now reports buildSha: 5fc9a5f, POST /api/models/discover answers 403 (route present, owner-gated) and GET /api/models answers 401. The deploy receipt at ~/.mso/private/update-state/<key>/deployed.json and the gateway state (runtimeOwned: true, new PID + runtimeInstanceId) were rewritten to match, and the restore inventory + restart-runtime marker were cleared.
Decision for this host: deploy with mso update / mso update --rebuild; treat bun run ship as push-only here. Its finalizer is design-correct only where an active systemd mso.service exists and the transient unit inherits a node-bearing PATH. No ship-script change was made — the fix belongs to whichever host owns a real service unit.
2026-10-17: Let a custom provider discover the models it actually serves
Adding a custom OpenAI/Anthropic-compatible endpoint meant typing model ids by hand; leave the list empty and the picker for that provider had nothing to show, because models.dev has no entry for a self-hosted slug. MSO can now ask the endpoint which ids it serves, the way OpenCode already does for known runtimes.
Discovery is explicit and owner-gated, never silent. POST /api/models/discover accepts either an unsaved {baseURL, apiKey, protocol} while the provider is being added, or a saved {provider} whose key is read from the host credential store, and answers {ok, count, models:[{id,name}]} — the key is never returned or logged. It calls the endpoint's own list API (OpenAI-compatible GET {base}/models, Anthropic GET {base}/v1/models) through the SSRF-pinned safeProviderFetch, with a size and time bound, mirroring the existing connection test.
In Settings → AI the new Discover models button renders the ids as toggle chips that write into the models field; the field stays authoritative, so discovery only fills in what the owner then saves. mso models add <name> --base-url … --api-key … with no --models queries the same route (the key travels over stdin via secret_post, never argv), confirms interactively or auto-fills in scripts, and falls back to manual ids on failure. GET /api/models?provider=<custom-slug> now returns a saved custom provider's stored ids instead of an empty catalog, so its Browse drawer is no longer blank.
2026-10-15: Let a cached OAuth client id authorize again, and unbreak the Semgrep gate
The consent page rejected every client_id it had not minted itself with "This client must register before requesting authorization", but ChatGPT's user-defined connector caches a self-declared id and never calls /oauth/register — so that client could never authorize. The rejection also added no security, because /oauth/register is already a public endpoint that mints a client for any https callback; the only thing it broke was clients whose registration had been swept (the store deletes unreferenced clients an hour after creation). An unknown but well-formed public id is now registered on demand at /oauth/authorize for its exact callback, and again inside the approval action so a swept registration cannot dead-end the click. The registration is server-side and inert until the owner approves and completes PKCE; server-owned MSO principals (manual:, pat:, mso_) and malformed ids still fail closed, and an existing client only ever has redirect targets unioned, never replaced. Client lifecycle moved to lib/mcp/store-clients.ts so both files stay inside the 220-line architecture ratchet.
The Security Core gate was failing deterministically at bff30987 on the Semgrep job with exit code 3 despite zero findings. Semgrep's bash parser rejects a one-line case whose pattern list contains | alternation, and --strict promotes that parse warning to a fatal exit; the trigger was scripts/cli/ai-provider-auth.sh:63. The arm is expanded to three lines, which parses clean, so the strict gate keeps catching genuinely unparseable shells instead of being relaxed.
A ChatGPT connector therefore reconnects against the callback it already holds; no re-add is required.
2026-10-17: Local hidden-prompt login password setup
mso passwd creates or changes the local installation login password without an HTTP session, password arguments, env-file execution or cookie-jar creation. It reuses login password validation and rotation; fresh configuration is published without overwriting another writer, mode 0600, with a random session signing secret and MCP disabled. Existing signing secrets and other configuration remain unchanged. Changing an existing password requires its current value. mso passwd status exposes configuration metadata only; no password read/delete operation is provided. The user must start/restart MSO explicitly to apply local file changes; existing sessions are not revoked. Tests use temporary installation fixtures, including a real PTY to verify hidden input and cancellation. No live installation credentials are created by development or tests.
2026-10-14: Fix the provider picker and make mso models add scriptable
mso models add with no argument died with mso picker: EAGAIN: resource temporarily unavailable, read. The native arrow picker read its candidate rows with fs.readFileSync(0), and Node throws instead of retrying when it is handed a non-blocking pipe that has not been written yet — exactly the state the manager's subshell pipeline produces. The picker now drains fd 0 through fs.readSync in a loop, sleeping on Atomics.wait and retrying EAGAIN until the producer closes the pipe, so the same selector works for both a pipeline and a redirected file. This restores the live provider list (Nvidia, OpenCode, OpenRouter, ZenMux and the rest) that the broken read had been hiding behind the static fallback.
Provider auth now matches the shape operators already use elsewhere: mso models add <provider> [--api-key <key>] [--type api-key|oauth] [--name <name>] [--base-url <url>] [--protocol openai|anthropic] [--models <ids>], with mso models add --help, a single-provider probe (mso models status <provider>), and the existing list/rm/catalog/test verbs unchanged. --api-key skips the hidden prompt so the credential can be supplied from a script or CI runner; the key still reaches the server through the stdin-bodied secret_post path and never appears in process argv. openai-codex and --type oauth remain device-flow sign-ins and reject a pasted key. Any unknown id carrying --base-url is treated as a custom OpenAI/Anthropic-compatible endpoint, and the custom subcommand keeps its interactive prompts.
The non-interactive path also exposed a latent terminal bug: tty_ok only tested [ -r/-w /dev/tty ], which stays true for a char device that exists while its open fails with ENXIO under a process with no controlling terminal. A prompt issued in that state wrote to /dev/tty, the redirect failed, and set -e killed the whole script mid-run. tty_ok now performs the real open, so piped invocations correctly fall through to the non-interactive defaults instead of aborting. Contract tests assert the new flags, the picker's stream read, and that readFileSync(0 never returns.
The provider-auth functions moved to scripts/cli/ai-provider-auth.sh, sourced by scripts/mso-cli-agent.sh: the added flag parsing pushed that slice past the 500-line architecture ratchet, and the boundary policy forbids raising the limit, so the auth responsibility now shares the ai-provider-catalog.sh pattern instead.
2026-10-10: Keep the raw-stream fixture fully visible to security scanning
Semgrep's pinned parser rejected the inline import type inside the mock loader's generic call. The fixture now applies the same module type to the awaited import result. All thirteen real-file stream tests and strict scanner coverage remain required; no rule or file is excluded.
2026-10-10: Close the three Medium findings from the 5a271a38 scan
Project workers now receive the exact initiating authority in both waited and detached execution. The shared runner requires that context, rejects scope escalation and combines parent cancellation with its own timeout. Real credential-store regressions cover child catalog/argument restrictions, token revoke/expiry, deployment changes and detached workers; parent cancellation also reaches model streaming.
Viewer raw-file responses admit four active streams per device and sixteen per process before opening a descriptor. Responses are capped at 32 MiB; larger files require ranges, oversized ranges are clipped and suffix seeking remains available. The Web stream queues at most 64 KiB, closes after ten idle seconds or sixty total seconds, and releases admission on descriptor closure, abort or cancellation.
MCP file resources claim read allowance under the existing cross-process security-store lock before allocating bytes. Failed reads never refund or resurrect claims. Four active reads per principal and eight per process bound allocation; saturation becomes HTTP 429 and the MCP rate-limit error. Ownership, session binding, expiry and integrity checks remain intact. Concurrent and saturation regressions cover exhaustion, cleanup and admission before file loading. Documentation also removes stale shared-cookie guidance and describes the existing audit rotation.
2026-10-10: Refresh workflow receipts after fast completion
Required CI exposed a status race: the first disk read captured a running receipt, then completion removed the pending promise while the authority check yielded. Positive-wait status requests now reread the receipt even when no pending promise remains. Wait limits, ownership, original execution authority and final live-authority checks remain intact. A deterministic regression reproduces the stale snapshot and fails before the shared fix; HTTP, MCP, webhook and repeat callers inherit the correction.
2026-10-10: Replace desktop streaming with a native repository knowledge view
The owner found the streamed Obsidian desktop slow and unsuitable for mobile, and requested a KISS implementation built on Organization and Memory. Agent Vault now reads the same separate private Markdown snapshots directly in MSO. Metadata loads first, note bodies load only on selection, and local title/type/source search adds no typing requests. Mobile navigation gives the list and reader their own full pane, with an explicit return action; desktop retains a sidebar. Capture history remains recorded repository evidence rather than live agent/deployment status.
The small inert Markdown reader supports headings, lists, quotes, fenced code, safe web references and links to exact published snapshot notes. HTML and embedded resources remain text. Backlinks reuse Memory's bounded owner projection only after a user asks, retaining that projection while moving between notes; the graph renderer stays deferred. Opening Memory supplies the exact selected snapshot context without replacing its saved defaults. Organization is linked through its existing app, preserving its identity and structure authority. Personal notes use a separate Notes/ folder, guarded Files operations and the existing Code editor rather than adding another editor, store or service. No dependencies, public API/MCP schemas, authorization rules or portable operator configuration change.
Regression coverage exercises safe/ambiguous/path-bounded link resolution and inert Markdown rendering. The required browser journey checks wikilink/backlink navigation, deferred connection reads, capture history, personal note creation/edit/save, separate storage, mobile list/reader reflow and live access denial. Instance domain cutover and desktop-runtime configuration remain private installation operations, outside the open-source project.
The personal-note journey also exposed a Code hydration bug: the initial empty buffer was compared with an absent disk entry and misclassified as unsaved, refusing the first host read. Treat the absent baseline as empty while retaining actual edits made during an in-flight read. The real editor/browser save journey verifies initial content and the written result. Host note editing respects the selected Live adapter; mock mode offers clear guidance instead of creating a note that its editor cannot read.
A follow-up parse experiment found quadratic work on long unfinished bracket sequences. Inline links now stop at nested bracket/parenthesis delimiters, retaining unfinished Markdown as literal text instead of repeatedly scanning the remaining note. Large malformed-note regressions preserve text and keep links inert; the reader remains dependency-free and bounded by the existing note limit.
The release fixture scopes extension refresh to its MCP tab panel: the shell window also exposes a Refresh action, so a page-wide selector was ambiguous. Discovery and its actual file-backed assertions remain mandatory.
2026-10-10: Close the eight findings from the 1acc1424 cloud scan
Candidate indexes use canonical credential guards during walking, seeding, cache reuse and preview reads; version 2 invalidates older caches. Git diffs use NUL-delimited filename metadata and literal pathspecs, omit protected patches/renames and redact recognizable credentials while retaining file statistics and ordinary source.
A2A SSE closes on terminal task state, profile revocation, disconnect and a five-minute deadline, with eight streams per profile, sixty-four globally and bounded queued events. Application and Camoufox child cookies retain the original session issue time and expiry independently of their short-lived tickets; HTTP and continuous WebSocket authority share those boundaries.
Durable session opening now requires write scope. Inbox reads reject acknowledgement; the dedicated write-scoped acknowledgement tool preserves normal receiver behavior. MCP waits carry request cancellation, recheck live token authority and discard results after revocation. Token administration cancels registered waits after durable revocation. The changed toolset signature requires downstream client action refresh; no existing token gains privileges.
Update status GET is cache-only; explicit remote checking uses a same-origin, rate-limited, audited POST. Google consent binds issue time and verifies durable logout both before exchange and inside token persistence. Regression tests cover both HTTP/MCP credential sinks, protected Git renames, terminal/revoked/cancelled streams, child expiry, read/write separation, late private results and logout during consent. Independent verification of the released commit remains required.
2026-10-10: Close the five findings from the 34b69798 cloud scan
Read roots default to the checkout and projects, not the whole home. Shared filesystem guards refuse additional Terraform, PyPI, Poetry, doctl, Azure and browser credential stores, plus raw project MCP/registry credentials. The dedicated project MCP inventory remains redacted. File Manager's initial listing selects an allowed root and canonicalizes its history; the sidebar no longer advertises disallowed Home paths. Explicit Owner root overrides remain available and subject to credential guards.
Workflow receipt identity includes graph and trigger node as well as principal/key. Matching legacy receipts retain their IDs; sibling graphs cannot reserve each other's namespace. Input/revision collisions still fail. Receipts retain creation scope and device role: status, waited status, stop, retry and idempotent replay recheck current authority. Owner-era receipts remain Owner-only after demotion even if their execution used a lower scope; legacy receipts require Owner/exec. Viewer inventory remains metadata-only.
Camoufox no longer selects an arbitrary executable from mutable cache. Repository pins bind the official Linux x86_64/arm64 archive checksums and complete installed file-tree digests for v156.0.1-beta.36. The installer verifies before extracting into private versioned runtime state; each launch verifies browser files/libraries, ownership, permissions and regular-file boundaries before touching authenticated profiles. Existing profiles/session snapshots remain intact; the optional service requires a reviewed installation.
Managed-app logs redact the entire Authorization value, including Basic, Digest and quoted headers. Persisted job records are scrubbed on write and historical records again on read, while ordinary update output stays readable. Regression fixtures cover credential denial through actual HTTP/MCP handlers, receipt collisions/demotion/revocation and legacy compatibility, browser artifact tamper/ownership/symlinks/special files, and current/historical log redaction.
The synthetic Google UI fixture waits for bind's replacement card before starting consent; receiving a bind request alone did not mean its reload had completed. Existing Google actions/assertions remain intact. Independent verification of the final released commit remains required.
2026-10-10: Give the OAuth browser fixture its own callback receiver
GitHub's required browser journey reached the synthetic OAuth callback and then mounted the catch-all MSO shell, which rewrote that unknown client path to the previously focused Settings window before the URL assertion. The fixture now supplies a bounded HTML callback receiver and removes it after testing. Actual registration, exact callback validation, PKCE exchange, state, pruned/manual-client refusal and desktop/mobile checks remain unchanged; production routes and security gates are not relaxed.
2026-10-09: Reuse MSO login for reviewed private applications
The bootstrap JavaScript is static: the login destination lives in percent-encoded HTML data, never code construction. A hostile app identifier cannot change the script or escape its data attribute; regression coverage executes the no-ticket redirect with hostile metadata.
The Vault window previously used a separate Basic login even after the Owner signed into MSO. Reviewed shell-only loopback applications can now opt into an isolated MSO-derived session through private registry state. The existing browser session supplies a short-lived, exact-origin ticket; its app exchanges that fragment-only ticket for a host-only cookie without sharing the cockpit cookie or password. Normal external connections keep their own authentication and portable manifests cannot grant this mode.
Every app HTTP request requires the current Owner role and durable device/session generation. WebSockets use the existing continuously authorized server relay, so demotion, logout, revocation and expiry stop both directions rather than authorizing only the initial upgrade. App cookies cannot authenticate cockpit APIs, upstream requests strip all MSO credentials, and duplicate hosts/off-box targets fail closed. The derived cookie retains the parent expiry independently of the one-minute ticket. Regression coverage checks purpose/origin separation, expiry, role changes, cookie stripping, proxy routing and production HTTP/socket handoff with synthetic stores. Instance ingress, domain and vault data remain outside source.
2026-10-09: Close the three findings from the 0af3e570 cloud scan
Public IP attribution ignores all forwarding headers by default. An explicit trusted proxy hop count selects a validated IP from the right only behind a firewalled origin; invalid or insufficient chains fail closed. Login shares the same helper. Fixed global admission budgets protect inbound A2A authentication and OAuth registration even when source keys rotate or the untrusted limiter pool churns.
Pending OAuth registrations remain intact at the 64-client capacity: excess admission fails rather than evicting consent state. Only unreferenced registrations older than one hour expire; live codes, access and refresh grants retain their clients. DCR metadata never establishes provider identity or file-host trust. All Azure downloads and redirects require an exact Owner allowlist entry, including rotating ChatGPT hosts; direct oaiusercontent downloads remain supported. Independent cloud verification remains required after release.
2026-10-09: Preserve security regressions without synthetic scanner noise
Post-release GitHub checks found two test-only matches. The growing-file regression now changes bytes through the already-open descriptor, preserving the actual-byte limit assertion without introducing a pathname check/reopen race in its fixture. Agent Vault constructs its deterministic redaction fixture from pieces; the original historical Gitleaks fingerprint is narrowly recorded after verifying every reachable commit. No production credential, scanner rule or release gate is excluded.
The public body admission journey sends oversized Content-Length headers before sending bytes, directly asserting HTTP 413 before body consumption without racing Undici's writer against the intended connection close. Eight actual near-limit bodies and the exact 200 MiB streamed authenticated upload remain required, with the same memory bound.
2026-10-09: Keep live-grant revocation tests independent of host load
The release lane rejected an epoch-revocation fixture before its first action: a fresh one-second grant can expire while the shared host is busy. Pin the fixture clock and advance it only for the dedicated expiry case. Every actual revocation, demotion, logout, epoch and expiry assertion remains active; production authorization and release gates are unchanged.
2026-10-09: Separate repository agent progress from portable MSO code
The owner asked for an Obsidian feature whose data reflects repository agents rather than personal starter notes. Agent Vault now provides a lazy native app, owner-only API, CLI and paired read/write MCP/Alfa capabilities over one guarded host implementation. Portable source contains no installation identity or user notes; source selection lives in private environment/browser state and each logical repository gets an independent data directory outside both source checkouts.
Bounded capture projects canonical agent/project pages, progress logs, platform inbox summaries, compact repo memory and recent commit metadata. Content digests deduplicate unchanged captures, published snapshots preserve history and user annotations, and metadata commits only after note writes. The existing private-store lock serializes capture for a repository across server processes. Raw transcripts, adapter state and owner recall are excluded; text is redacted and collection limits stay visible. Snapshots describe recorded evidence, never live agent or deployment health.
Regressions cover repo isolation, source preservation, corrupt manifests, secret/transcript exclusion, path/symlink refusal, private permissions, owner access and scope/audit parity. Synthetic browser journeys exercise note reads, changed/old snapshots, search, mobile reflow and live role revocation. The fixed snapshot ceiling refuses further capture without deleting history; no automatic schedule or native desktop launch is added to the portable feature. Agent Vault follows Settings in the mobile catalog so existing first-page apps stay reachable. Compact expandable details keep notes reachable in short landscape windows, and shared sidebar styles preserve the existing shell CSS budget. Compact ChatGPT one-line descriptions use a smaller character cap to admit the two tools within the existing scanner budget, retaining all names, schemas, scopes and permission checks.
2026-10-09: Close the ten findings from the b2f4f607 cloud scan
Remote federation scope/confirmation fields no longer grant local authority. Every MSO and standalone SI-Coder request needs a private, one-use Owner approval bound to its exact request, project, operation, scope and arguments, with a maximum 24-hour expiry. Missing, revoked, expired, changed and replayed approvals fail closed. Durable federation delegation remains unavailable until it can propagate a revocable local grant.
Opened filesystem descriptors reject virtual kernel filesystems even through bind mounts; text/binary reads count actual bytes. Isolated workflows pin their worktree boundary throughout capability calls and validate actual write descriptors and process directories. Hermes lifecycle/state checks include every catalog unit and both systemd scopes; backup/update snapshots require every service to be stopped and recheck throughout copying; restore rechecks after its undo snapshot and during copying. The operation lease prevents concurrent MSO lifecycle actions; a detected external restart aborts the snapshot or restore.
Owner channel configuration binds the exact graph owner, node and revision, rejecting ambiguous IDs and requiring legacy bindings to be reviewed again. Organization local sessions retain the original web execution principal despite using a CLI alias to find the stored session; delegated calls recheck the live device. Discord rejects stale/future signed requests, and a bounded durable admission receipt precedes session allocation. Stored A2A credentials require exec authority even for task reads.
Cockpit cookies are always host-only, invalidating legacy Domain sessions. Managed-app dashboards and sockets use separate origin- and purpose-bound credentials bootstrapped from a short-lived ticket; users must sign in again and reopen dashboard windows. Public middleware body cloning is bounded to 1 MiB; the exact upload endpoint bypasses cloning, enforces its own app-host/CSRF/Owner gate before reading, streams up to 200 MiB and admits four concurrent uploads. Tests cover the real filesystem/store boundaries, signature purposes, role/revocation, colliding graph IDs, concurrent replay admission, all-unit stop and service restart before restore. Independent cloud reassessment remains required after release.
2026-10-09: Pin the bounded MCP store read and review the inference-test alert
Post-release CodeQL found a check/reopen race in the new store byte limit. The reader now opens once with no-follow/nonblocking flags, checks and reads that descriptor into a size-bounded buffer, rejects growth/content changes and closes it on every path. Real-file regressions replace the pathname after open and grow the file after the size check. Atomic replacement still permits reading the original consistent snapshot.
CodeQL alert #159 traces the selected model name from config.json into the Owner-only inference test's model field. That transmission is intentional: the request has a static ping, one-token budget, registry-selected built-in endpoint or the existing custom-provider SSRF guard, and no arbitrary file payload. It repeats the previously reviewed alert #22. Regression tests prove the Owner boundary and exact custom-provider request body. Only this specific false positive is reviewed; scanners, rules, inventory enforcement and real findings remain enabled.
2026-10-09: Close the eight findings from the independent security rescan
The completed rescan of dac56bdf found six Medium and two Low issues, with no High findings. Named MCP integrations now reuse the private endpoint-bound transport and recursive credential redaction rather than embedding bearer headers in an unbound server. OAuth consent accepts only server-generated registered client identities and their exact callbacks, preventing manual/pruned client IDs from aliasing another principal. The obsolete manual Client ID guidance is removed; clients must register and reconnect for new consent. The browser proof also exposed the consent grid's minimum-content width overflowing a 390px viewport; its card now permits shrinking, retaining readable content and the desktop/mobile reflow assertion.
Async subagents, on-demand local workers and flows retain the initiating durable grant, profile, tool allowlist and argument constraints. Shared execution authority revalidates that grant and the deployment ceiling before every model round/action; browser flows retain their signed device session so revocation, demotion, logout, expiry and cookie-epoch changes stop later steps. External A2A workers reload their durable profile, intersect live scope and abort active profile tasks on token removal. Fixed-workflow lifecycle controls use one filter for both model advertisement and invocation.
OAuth rotation now has a persisted 30-second family limit, absolute 90-day grant expiry, expired-access pruning, bounded revoked/replay history and count/byte admission limits. Provider responses have server deadlines plus byte, SSE record/event, text, tool-count and aggregate-argument budgets; errors read only a bounded prefix and unused bodies are canceled. Regression tests exercise actual credential/device stores and mid-execution changes, reflected schema/result/error credentials, hostile provider streams, and registered/manual/pruned OAuth consent in the real browser release lane. Historical cloud findings remain scan evidence; closure requires independent reassessment of the new release.
2026-10-09: Keep the cookie browser proof in the mandatory browser release lane
The GitHub Verify job found that the new cookie proof needed Chromium before the unit/coverage lane installed a browser. The same unskipped proof now runs through the mandatory release browser configuration, after the existing Playwright preparation step. It still tests sibling Domain/path cookie injection in both insertion orders using the production helpers. Core verification remains usable on a fresh host; no runtime authorization, scanner gate, dependency or test assertion was relaxed.
2026-10-09: Close the seven remaining repository-scan trust boundaries
The October 8 scan at fe9d66ed identified seven separate gaps. Workflow Operator grants now intersect caller tool/argument restrictions with reviewed bounded app actions and recheck the live role per node; both directories reflect the effective authority. A2A applies the live deployment ceiling at dispatch, every model round and every tool call. Fresh installs fetch the exact requested branch/tag/commit and stop on failure, with verified bootstrap hashes refreshed.
Filesystem reads inspect opened handles and streams retain those handles. Writes, mkdir, copy, move, recursive delete, enumeration and uploads hold directory descriptors; ZIP reads create a bounded credential-filtered private snapshot. Canonical configured roots do not gain authority when replaced with symlinks. Official Linux/WSL and macOS/Termux Linux guests provide the required descriptor primitives; unsupported native hosts fail closed. Managed-app cookies are HTTPS host-only __Host- cookies; legacy/duplicate names are refused and existing app sessions may need a new login. OAuth discovery ignores untrusted forwarded authority and is not cacheable. Local-agent SSE retains signed-session authority, checks before delivery and during idle periods, bounds its queue and releases subscriptions/timers on closure.
Regression tests exercise real ancestor exchanges, protected credential exchanges, pinned downloads/uploads, exact tag/raw-commit and missing-ref installations, both A2A transports and in-flight ceiling changes, Operator capability denial, cookie shadowing and signed-session revocation/demotion/logout/expiry/epoch rotation. Cloud reassessment subsequently launched and completed despite inconsistent quota availability metadata; historical findings are not marked closed by local evidence. Runtime deployment requires the repository release path and a matching live build identity.
2026-10-08: Remove duplicate macOS chrome values from components
The user's SSOT/DRY follow-up exposed a real duplicate: menu width lived separately in placement metrics and CSS, and the macOS row height estimate had a separate h-6 class. One macOS geometry definition now feeds placement plus menu-bar/context/submenu widths and context row heights, retaining the 44px coarse-pointer floor. The macOS stylesheet owns common chrome font size, semantic weights and titlebar heights; JSX no longer repeats those reference values. Palette/material remain scoped to the skin and existing menu/window components still own behavior. A rendered submenu regression changes supplied geometry and proves that both panel and rows follow it; browser checks cover dropdown/context/widget widths, typography, themes, keyboard, bounds, touch and the Windows round trip. Menu width measurement waits for the existing opening animation to settle, matching the established context-menu geometry check; it never relaxes the 244px contract. No global primitive, app action, dependency or gate budget changed. Overall Figma migration progress remains unquantified until the remaining component inventory and acceptance scope are mapped; four completed incremental packages do not establish full-view fidelity.
2026-10-08: Align shared macOS window title and control edges
The open Figma composed window Title uses SF Pro Bold 13px with a 15px line height; MSO rendered Semibold with 19.5px leading. Close and Minimize properties confirm the existing 14px colors/geometry and a 0.5px inner black stroke at 45%, rather than MSO's 35%. The shared macOS window title now uses the reference weight/leading and its control CSS uses the matching edge. All macOS app windows consume that one branch; Windows retains its separate caption and mobile/dashboard use WindowContent directly. Focus gray, hover/focus symbols, 24px targets, close guards, window/store actions and theme colors remain intact. Browser checks measure actual title typography in both themes and the rendered control edge alongside existing maximize, restore, drag, resize, minimize, keyboard and shell-switch journeys. No app-specific title override, configuration or dependency was added.
2026-10-08: Match macOS menu symbols to their labels
The open Figma menu uses the same primary color for normal labels and symbols, with white symbols on selection. MSO context icons previously kept the generic blue accent and labels overrode the macOS palette. Context/submenu rows now inherit the existing macOS primary color, and their shared row body leaves icons inheriting the row alongside existing dropdown icons, checkmarks and arrows. Destructive rows retain their existing red token. Windows and touch-shell colors keep the shared component's previous behavior. Browser checks compare actual symbol/label colors in both themes and after a Windows round trip, and exercise the widget consumer's Medium checkmark and Remove widget row without invoking removal. The existing CSS bundle cap rejected an extra rule/utility, so the final implementation removes macOS-only color overrides without adding CSS. No budget, selection contract, action or dependency changed.
2026-10-08: Unify shared macOS menu glass material
The Figma menu already matched MSO's 12px corners and 8px/48px outer shadow. Browser properties also showed a 0.5px Plus Lighter glass edge; native refraction is intentionally approximated with CSS. Context/submenu panels previously inherited a different blur from dropdowns, despite sharing the same macOS chrome. The macOS menu rule now owns the existing blur/saturation material and a thin highlight for all three surfaces, with readable theme backgrounds retained. Reduced glass disables both standard and WebKit filters. No global glass helper or other shell metric changed. Rendered menu checks verify the shared material in both themes alongside geometry, keyboard, contrast and shell-switch regression checks. The full gate exposed an existing enumeration fixture that resolved credential aliases in the operator home; its synthetic HOME and read roots are now isolated and restored without changing runtime deadlines, admission or coverage thresholds.
2026-10-08: Align shared macOS menu typography with the open Figma kit
Browser inspection of the user's macOS 27 kit showed SF Pro Medium 13px menu labels and shortcut symbols. MSO's menu-bar rows were Regular and its context rows inherited a larger size; all portaled macOS menus also overrode the existing Apple font stack with system-ui. The macOS menu rule now owns 13px Medium typography for all three menu surfaces, and menu-bar, context and submenu panels use the existing data-shell-id font authority. App actions, window state, pointer target sizes and other shells retain their existing contracts. The browser regression checks actual menu-bar/context typography in light, dark and after a Windows round trip, alongside the existing geometry, contrast, keyboard and touch checks. Figma MCP access was exhausted; the user explicitly authorized browser properties as the reference. SF Pro falls back through the existing platform font stack when unavailable.
2026-10-08: Close follow-up scan authority and resource gaps
The latest scan of main 40e30906 reported 14 remaining issues. Exact-loopback A2A now carries the current caller's exec authority across discovery, selected interfaces and credential materialization; reflected outbound secrets are removed from JSON, SSE and errors. Project skill ownership no longer promotes repository instructions into trusted guidance. Organization seat targets require exec changes and saved graphs pin their reviewed target digest. Durable standby retains live credential references and rechecks both request and worker grants, including per-capability constraints, after recovery.
Production socket forwarding owns live device checks in both directions and while idle; logout invalidates viewer tickets/cookies and cockpit sessions durably, and terminal streams stop on owner-authority loss. Health probes refuse redirects. Webhook admission uses a fixed global pre-auth budget independent of attacker-controlled IDs/source-map churn. Filesystem guards check lexical paths and protected canonical aliases; writes use random exclusive no-follow temporary descriptors. Enumeration streams within entry/time/response/concurrency ceilings, and service actions limit bytes before parsing.
Regression checks exercise real token stores, sockets, terminal streams, aliases and queued/recovered execution. No gate budgets were raised and no dependency was added. Cloud findings remain tied to the scanned historical revision until separate reassessment; repository checks do not establish production deployment.
2026-10-08: Preserve heartbeat configuration across cron working directories
The final audit reproduced a cron check silently becoming disabled when installation used a caller-relative env file. The shared heartbeat entry point now anchors that path to the installation working directory before validating it, preserving symlink rejection. A regression executes the generated cron command from HOME and confirms the enabled health check still runs.
2026-10-08: Make shell startup and Spotlight feedback reliable
The boot splash now removes itself on hydration on every route, including the standalone Integrations and OAuth pages, and uses the saved theme before hydration. Spotlight reports pending folder searches and retries focus after its deferred mount while retaining first-open lazy loading. Its foreground and placeholder colors remain readable over the desktop wallpaper. The update badge uses the Settings public entry point and sits below the separate install prompt. The release journey checks that the standalone Integrations page has no remaining boot overlay and that install/update notices do not overlap at desktop and 320px mobile widths.
2026-10-08: Complete the scan hardening audit and repair verification
The three Codex Security Cloud scans overlap across authority, credentials, ingress, resource ceilings and installation provenance. The security branch now includes webhook authentication, distinct PAT principals, refresh-family replay revocation, explicit exec authority for loopback discovery, immutable managed-app update targets, provider environment SecretRefs, proven gateway ownership, bounded audit tails, backup retention and pinned NodeSource bootstrap bytes.
Independent verification additionally found that archive admission ended before its unlinked output descriptor closed, temporary-directory failure could strand admission, and delegated write could replace user-local launchers or their parent directories. The shared guards now cover those paths and managed-runtime trees; archive admission lasts until stream closure with a bounded lifetime. Backups recheck file/byte limits during copying and remove incomplete snapshots on failure. Installer bootstrap checksums were refreshed after the core hardening. Gateway test launchers now emit valid JavaScript, and the equivalent listener-port comparison parses correctly under strict Semgrep. OAuth and workflow fixtures explicitly exercise replay revocation and live approved-device authority.
These are source and verification changes. Production deployment and scan closure require the verified main revision and live runtime evidence; local tests alone do not establish either.
2026-10-07: Harden delegated workflow, ingress and credential boundaries
Two repository security scans (October 2 and October 7) exposed overlapping authority and ingress gaps. Project dotenv files are now credential material everywhere, recursive archives exclude them, exact-loopback A2A is opt-in, and pre-auth A2A traffic cannot evict authenticated rate-limit state. Project ingress requires bounded framing and forwards only protocol headers, not cockpit cookies or Authorization.
Workflow Graph execution now treats stored definitions as data rather than grants: live web-device role and deployment scope are rechecked before execution, Operator authority caps at write, unattended stored non-web principals fail closed, error workflows carry ancestry, and typed/short secret variables are redacted from receipts. Public JSON/form readers used by login, OAuth, Discord and setup enforce actual byte ceilings and deadlines before parsing; login admission is reserved before password comparison so a distributed source cannot continue the password oracle past the global budget. OAuth consent now describes the real breadth of write authority.
Regression coverage was added for these boundaries. This entry does not claim closure of the remaining archive-size, backup-retention, audit-growth, installer-supply-chain, OpenClaw argv, workflow-webhook authentication, or write-to-control-plane findings; those require separate verified changes.
2026-10-06: Optional one-shot fallback heartbeat
A named connector can remain alive while its public connection is unavailable. The opt-in mso heartbeat checks structured gateway local/public identity and recovers only MSO-owned fallback processes through the existing lifecycle. It is disabled unless OS_HEARTBEAT_ENABLED=1, needs an explicit validated named-gateway recipe before stopping a managed connector, and leaves external supervisors report-only. An idempotent optional cron installer schedules 30-minute and cron-startup checks without adding a monitoring daemon or replacing unrelated cron entries. Private scoped locks prevent overlapping recovery and status retains no credentials. Platform startup and workspace suspension remain host responsibilities.
Focused regressions cover disabled behavior, consecutive failures, public health, managed recipe preflight, external ownership, malformed observations, private env files, local fallback recovery and cron preservation. This is a PR candidate; no production installation or main branch is changed.
2026-10-06: Patch source-map-js and retain the 9Router proposal
Hosted Verify and OSV identified GHSA-68fv-2mgg-jv7q in the locked source-map-js 1.2.1 dependency. The targeted update resolves it to the patched 1.2.2 without changing package ranges, audit policy or existing dependency patches. A fresh frozen install loads the native PTY module, and both strict and native Bun audits are clean. Full combined-head repository, build, browser and security verification remains required before integration.
The reviewed PR 102 app-host RFC is retained from source commit 3fcbe16997c23e03da8efad548abd9ff62ec4f27 and indexed as a proposal awaiting implementation. All tenant documentation stays in place. CodeQL and DAST workflows remain unchanged; this documentation reconciliation performs no routing, cookie-domain, credential or production configuration change.
2026-10-06: Preserve overlapping standby wakeups
The PR integration exposed a dropped-wakeup race in local-agent standby: a drain requested while another pass was reading an empty mailbox returned immediately, so a newly invalid workflow or arriving authorized message could remain unprocessed. Concurrent drains now share one completion promise and request a fresh validated pass. Cleanup happens inside the runner's own finalization step, without a microtask window that could discard a late join. Per-pass bounds, sequential message execution, claim checks and fatal blocking remain intact.
Three deferred-promise regressions reproduce the empty-snapshot and finalization boundaries without timer delays; each failed the relevant earlier implementation. The existing stale-workflow and sequential execution tests remain unchanged. Models-catalog tests also prove that denied owner authorization returns 401 before either ordinary catalog or OAuth-account access, for Codex, regular and empty provider selectors. Focused checks and full local coverage passed 4,041 tests across 673 files; final publication checks and the separately identified dependency advisory remain pending.
2026-10-05: Reconcile reviewed shell and tenant candidates
CI keeps the strict dependency-audit wrapper, including its timeout, malformed-report checks and redacted diagnostics, and adds the native Bun high/critical audit as a separate required step. Both run after removal of the vulnerable dependency chain and its exception files. Workflow permissions remain read-only. A contract test prevents either audit from becoming optional.
The integration starts from current GitHub main and preserves its content-versioned wallpaper URLs and dependency updates. It combines the managed-app return refresh, linked-worktree lint boundary, disabled-by-default tenant identity and durable memory runtime, reviewed macOS chrome, and privacy-safe iOS lock and home changes. Tenant credentials retain exact issuer, subject and binding-generation checks; the normal legacy mode remains the default and no live tenant registry, grants or storage are configured.
The macOS source tree is reproduced from reviewed candidate dc74b7af, while its deleted intermediate wallpaper PNGs remain in the preserved source history. The iOS history is preserved through 846dbfea. The dependency reconciliation retains Vitest and coverage 5.0.2 and removes the vulnerable braces chain through the reviewed bounded expansion patches; neither the advisory-wide local ignore nor the superseded scoped waiver is carried forward. Full repository, raw/strict dependency, isolated-build, mandatory release, macOS and iOS browser checks must all pass on the combined head before publication. This source integration does not rebuild or restart the live installation.
2026-10-05 — Refresh managed-app install state when returning to App Store
The managed-app backend already detected a healthy Docker-managed 9Router installation, but the App Store catalog read /api/v1/managed-apps only once when mounted. Installing 9Router in its separate MSO window could therefore leave the background Store card showing Not installed until the Store was reloaded, even though the server was already running. The catalog now refreshes managed-app state when the document becomes visible again or the window regains focus, while leaving the remote MANEF catalog fetch mount-only and avoiding background polling. This changes only Store state synchronization; 9Router lifecycle, container detection, credentials and runtime configuration are unchanged.
The release gate also now ignores .claude/worktrees/**, which are Git-ignored linked task checkouts and must be linted from their own roots rather than re-scanned from canonical main. This does not relax lint rules for tracked MSO source.
2026-10-04 — iOS lock safety and integration candidate
The PR 104 follow-through removes automatic geolocation and external weather requests, restores the original non-iOS privacy curtain, removes the inactive camera button, and labels the existing actions accurately as Lock screen and Hide from Home. Weather remains unavailable pending a separately reviewed explicit opt-in. The iOS Unlock control now has a 44px target, visible keyboard focus, Tab containment, and focus restoration. Locale matching compares complete language/region subtags rather than a partially anchored regular expression. These safety changes supersede the weather, camera, and biometric-label behavior described in earlier candidate entries below.
The isolated candidate passed 366 tests across 52 files, architecture/docs checks, targeted lint, a production build, and four mock-only browser cases covering phone/tablet, light/dark, keyboard and focus, no location/provider calls, and the original macOS lock/unlock after landscape switching. Current-main integration preserves both progress histories; its full gates are verified separately. This is not a deployment or a claim of Figma pixel fidelity.
2026-10-04 — Lock time Semibold
The lock time stays 92pt cream and one device-local line. The weight is Semibold, the Headline and emphasized Title 3 weight, because Regular was still too light. It does not return to 96pt.
2026-10-04 — Smaller home widgets, lock time weight, glass fill
Home widgets sit in an 80px icon grid instead of stretching with the page. Small is 2×2, medium is 4×2, large is 3×3 with icons beside it, and extra-large is 4×3 with icons below, so none of them fills the home. The lock time is 92pt Regular, the next SF Pro size under 96pt and the Large Title weight, with tracking 0, still one cream line. Search, the dock, lock complications, and Control Center tiles paint the glass fill, including the tiles that render outside the shell.
2026-10-04 — Lock date line and cream time
The lock date is a short device date, Footnote size, tight above the time. The city is added on that line only after the location grant returns a name. The time is 96pt light cream at 78% opacity. Weather fallback, wallpaper, flashlight, camera, and complications stay.
2026-10-04 — iOS lock screen on the shell wallpaper
The iOS lock face now follows the lock-screen frame: status bar, date, one large time, weather, activity rings, a round clock, flashlight, camera, and the home indicator. It uses the shell wallpaper. The home stays hidden, so the curtain is not a blur of the icons. Clock, date, and timezone come from the browser Date and Intl. Weather is a client geolocation prompt plus a client forecast; a denial shows Unavailable and does not ask this server for a place. In a standalone PWA the system status bar keeps the top inset and the shell does not paint a second one. The macOS curtain is unchanged.
2026-10-03 — Lock date tracking and full-screen cover
The lock date keeps Title 3 emphasized (20/25 Semibold) and now uses tracking +0.38. While the iOS shell is locked, the home does not paint through the curtain, so the lock surface covers it. Flashlight and camera stay the circular glass buttons. Other type sizes are unchanged.
2026-10-03 — iOS type styles and touch sizes
Home labels, the search pill, widget titles, menu rows, the lock date and time, and Control Center type now use Apple’s Large Dynamic Type styles instead of nearby one-off sizes. Icon labels are Caption 1 (12/16 Regular). The search pill and menu rows are Body (17/22 Regular) with a 44pt target and 16pt inset. Widget and card titles are Headline (17/22 Semibold). The lock date is Title 3 emphasized (20/25 Semibold) and the lock time is 96pt Regular, which is the size whose SF Pro tracking is 0. The macOS shell is unchanged.
2026-10-03 — Widget homes, lock type, Control Center mosaic
The purple widget sizes were stacked on Today, which hid the icon grid. Each size is now its own home screen: one placeholder in the 4×6 grid and the existing apps in the cells around it. The plain icon home, search pill, and icon dock stay. The lock clock was rendering the day period as a second giant line in black on the blurred wallpaper; it is now one light 12-hour time under a small light date. iOS Control Center is a single packed mosaic (circle group, tall card, two lower tiles) of the toggles this shell already has.
2026-10-03 — iOS 27 home screen frames
The first pass treated a third-party tab-bar measurement as the Home Screen. The linked Figma page is a different frame: the dock is a glass capsule of app icons with no labels, and Search is a separate pill above it. Grid icons keep their labels, and the page dots stay. Today shows the four widget sizes as purple placeholders named for the widgets this shell already has. The lock screen keeps the clock and puts the date above it, with flashlight and camera controls. iOS Control Center is a glass tile mosaic; the macOS menu-bar popover keeps the shared labeled list. A home-icon long-press is a floating menu (Remove App, Require Face ID, Edit Home Screen, then that app's own actions) instead of a bottom sheet. The macOS shell is unchanged.
2026-10-04 — Version replaced default wallpaper URLs
The deployed light wallpaper reused an immutable one-year URL. Browser evidence still returned the old 40,480-byte mountain image while origin served the new 47,714-byte light asset. The CSS now includes each default image's content hash in its URL, so existing client/CDN caches request new bytes without clearing custom wallpaper preferences. A regression ties both light and dark URL versions to their actual image bytes.
2026-10-04 — Descriptor assertions and validated trace snapshots
The native installer fixture checks file permissions and reads its content through one no-follow descriptor, closing it in finally rather than checking and reopening a pathname. A2A trace persistence now requires primitive session/workflow identifiers, rejects accessors and unknown fields, builds a fresh allowlisted scalar snapshot, and serializes it before filesystem awaits. Caller mutation or toJSON hooks cannot replace validated content. Private exclusive JSON writes and atomic rename remain; the byte cap matches readState's limit. Regression tests cover malformed IDs, custom hooks, asynchronous mutation and valid maximum escaped metadata. These are real validation fixes; closure of the network-to-file review finding still requires fresh exact-commit CodeQL evidence.
2026-10-04 — Remove vulnerable build and lint dependencies
The locked node-gyp bootstrap moves from 11.5.0 to 12.4.0, removing make-fetch-happen and http-cache-semantics while retaining MSO's Node support. Next ESLint's fast-glob traversal stays unchanged. Its micromatch dependency aliases the same underlying picomatch 2.3.2 matcher; a versioned Bun patch replaces only brace expansion with maintained brace-expansion 5.0.12. A second patch makes both CJS and ESM expansion entrypoints throw on result, encoded-length, depth or rewrite exhaustion instead of silently returning partial patterns. Regression fixtures cover actual lint diagnostics, path and brace semantics, escaping and each limit. Broader tinyglobby and glob replacements were rejected after differential tests found compatibility changes. The vulnerable braces package is removed without exemptions.
Semgrep's parser rejected the inline import type in a mocked-module spread. A named type alias preserves the same mocked exports and assertions while restoring complete strict parsing. Raw dependency audit and scanner policies remain unchanged; PR 105's exceptions are not adopted. Final CI and integrated UI verification remain release-candidate gates.
2026-10-04 — Security Core dependency and Semgrep gates
Historical PR 105 decision: the temporary braces exception described below has been retired by the verified dependency replacement above. Raw audit and OSV scanning no longer exempt it.
OSV-Scanner 2.5.1, Trivy, and bun audit --audit-level=high were red on 2690b5e and on PR 104 (ec38f332) for two unfixed HIGH advisories. npm still lists braces 3.0.3 and http-cache-semantics 4.2.0 as the newest releases. node-gyp 12.4.0 replaces make-fetch-happen with undici, still accepts MSO's Node range (^20.17.0 || >=22.9.0), and the regenerated scripts/install/node-gyp/package-lock.json no longer contains http-cache-semantics or make-fetch-happen. npm audit --omit=dev --audit-level=high on that prefix is clean, so the Trivy filesystem finding and the OSV finding for GHSA-ch52-4w7c-c8xp leave with the package. node-gyp 13 was not used because it requires ^22.22.2 || ^24.15.0 || >=26.0.0.
braces 3.0.3 remains only on the dev chain eslint-config-next → @next/eslint-plugin-next → fast-glob → micromatch in bun.lock. The Next plugin calls fast-glob only when settings.next.rootDir is set, and eslint.config.mjs does not set it. No MSO source imports braces. Root osv-scanner.toml ignores GHSA-vfj7-8cjw-p6xm until 2026-12-03T00:00:00Z and, because OSV config does not propagate to child directories, does not cover any other lockfile. scripts/audit-exceptions.mjs applies the same GHSA, instant, and chain check; CI's audit step calls bun run audit:strict instead of a blanket bun audit --ignore. A second parent, a production dependency, a different package, or the expiry date fails the audit again.
Pinned Semgrep 1.174.0 with --strict --error --verbose partially parsed only app/api/config/route.test.ts line 14 (PartialParsing on the spread of await importOriginal<typeof import(...)>()). The mock now awaits a named ConfigStore alias and spreads that value. --strict and --error stay enabled.
2026-10-02 — Alfa configuration and inference readiness
Alfa's shared configuration route rejects malformed selections before writing, preserves the active provider on model-only changes, and stops provider changes from inheriting another provider's model. Codex needs an explicit account model when switching; custom connections without a model stay connect-only. Environment-backed built-ins now appear in the connected-provider list without exposing their keys. The Codex connection test uses the existing streaming adapter for a bounded inference check instead of relying only on model-list access. No additional AI SDK dependency is needed for the existing provider path. Regression checks cover malformed input, provider/model preservation, connect-only behavior, environment credentials and inference failures. Live Codex chat and a harmless function-call/result round trip were verified before release; deployment proof is recorded separately by the workflow.
The strict release audit found Next.js 16.3.5 affected by GHSA-vcvr-r3jv-pc5j. Next.js and its matching ESLint configuration move to 16.3.8, with a clean strict dependency audit and a verified node-pty load. Shared-host verification uses a private umask and bounded Vitest workers; the original failed fixture cases pass under those conditions without relaxing security, timeout or coverage thresholds.
2026-09-30 — Follow-up scan: atomic CLI state and native environment
The exact security release closed all seven reported alerts and exposed two file-check/use findings in previously integrated native-install and A2A-trace code. Native environment creation now uses one exclusive descriptor while preserving existing configuration, and all saved trace reads use a capped O_NOFOLLOW descriptor. Trace persistence accepts only known bounded metadata fields and validated identifiers; malformed API metadata is rejected before writing. The remaining network-to-file finding is intentional private JSON session/workflow metadata persistence, never an executable download; review and scanner state are recorded separately from the two code fixes.
2026-09-30 — Code-scanning filesystem boundary fixes
Closed the shared bounded-reader gap with lexical and real-parent containment against configured read roots (or the explicit root of an already-authorized internal store/skill scan) while retaining final-component O_NOFOLLOW and pre-allocation size limits. Repository-memory project roots use the host read guard and reject a symlinked memory parent before reads or writes. Project knowledge rejects redirected metadata directories, and linked-worktree lookup checks lexical containment before probing a caller path. The memory-backup CLI fixture now executes a fixed Bash file instead of dynamic shell code. Regression fixtures explicitly authorize their temporary roots and exercise traversal, out-of-root access, symlink parents and preserved valid reads. The current lockfile already contains brace-expansion 1.1.21 and 5.0.12, which cover the three advisory IDs in Scorecard alert 118; scanner closure must be verified against the released SHA. Release-gate count/identity fixtures now use a fixed clock, keeping their assertions independent of a concurrent build while the dedicated deadline/cursor regression still exercises the real production budget.
2026-09-30 — Reconciliation takeover verification
Recovered the interrupted reconciliation in a separate worktree while preserving the original conflicted checkout and verified all-ref backup. The split CLI dispatcher retains the exclusive service-start/restart lock from the rescue branch, and Hostinger wildcard owner validation is recovered with its existing bounded-payload regression. Local-agent lifecycle initialization remains within the source-size gate without disabling lint. The combined candidate passed 3,723 tests across 649 files, all 16 CI runner contracts, typecheck, lint, architecture/docs/contrast checks and dependency audit. Native-host physical acceptance and unrelated legacy histories remain preserved; these are not claimed completed by this integration. Runtime release is verified separately through the official ship gates.
2026-09-30 — Repository reconciliation candidate
Integrated committed Update navigation, provider-neutral A2A traces, Assistant run state and scoped approvals, native host adapters, and the isolated CI runner. Historical branches with identical patches and package changes are reconciled as ancestry without replaying superseded source. The complete all-ref bundle was verified before cleanup. Dirty worktrees, stashes and unrelated legacy histories remain preserved until their work can be individually verified. Native host candidates remain outside the public installer pending physical-machine acceptance. This entry describes the integration candidate; main merge and runtime release require the normal gates.
The combined suite identified a missing synthetic Assistant E2E fixture and undocumented A2A/PowerShell environment options; both are corrected without weakening validation.
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 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.
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 — Allow exact wildcard Hostinger DNS owners for Batonly staging
The bounded Hostinger DNS adapter now accepts a leading wildcard label in the requested owner while preserving all existing per-RR-set safeguards. Validation still resolves the exact portfolio root, refuses ambiguous rows and CNAME/A conflicts, and sends one overwrite payload containing only the requested name/type. This enables wildcard staging under batonly.site to route deterministic Batonly preview hosts to the verified Dokploy origin without creating one DNS record per preview.
A dedicated regression asserts that the wildcard request writes only the wildcard staging owner and leaves unrelated zone rows outside the provider mutation payload.
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 — Tighten Workflow builder UX and Organization group focus
The bounded Repeat Until release completed the missing control-flow primitive, but the visual construction path still required more ceremony than mature workflow editors: node creation was a flat popover, adding a next step meant creating then wiring it manually, and collapsed Organization project groups could not become an explicit focus context. This pass improves those interaction gaps without changing Workflow execution authority or Organization persistence.
Workflows now uses a categorized node creator across Triggers, Actions, AI, Flow and Context, with search, keyboard-first first-result insertion, clearer node-family cards, and a contextual + on every executable output. Quick-add opens an after-node picker that intentionally excludes triggers, positions the new node to the right with sibling spacing, preserves the exact branch handle, creates the edge in the same editor mutation and opens the new node in Inspector. The reusable subflow node is presented as Execute Workflow while retaining the existing subflow contract. Canvas cards now distinguish node families and surface live run state more clearly. Collapsed Workflow groups can be selected and managed directly instead of behaving like inert proxies.
Organization project-flow groups now act as Paperclip-style focus boundaries without changing the Organization data model. Selecting a collapsed group opens a member summary, permits direct member navigation, focus/exit-focus, expand/collapse and presentation-only ungrouping. Group focus keeps all members plus their one-hop external dependencies visible; search also resolves group names. The implementation remains presentation/context metadata only: reporting lines, seat routing, Workflow topology and agent/A2A execution authorities stay in their existing stores.
Documentation was reconciled across Workflow Graph, Organization, A2A and Automation Flows. The n8n-parity section now distinguishes practical interaction parity from visual cloning and explicitly records remaining gaps such as n8n's richer drag/drop data mapper and community-node ecosystem. A2A now states that it is the remote transport boundary, while Workflow owns repeatable topology and Organization owns stable seat/routing identity. Targeted regression, typecheck, lint and full bun run verify pass on the candidate working tree; the committed candidate must still pass the official isolated build/browser release gate before shipping.
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, verifiedworkflow_finish(success=true), user-facing Workflow create/save/restore (including session→draft), and Organizationflow_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_startcompact 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
replacewrites now resolve to deterministic NOOP instead of growing redundant ledger history; explicit temporal/provenance timestamps and parallelclaimevidence 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_REPOorigins are never rewritten and retain their ownorigin/mainauthority. - 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..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. Keep that guard intact. A typed refusal now distinguishes these private addresses from loopback, metadata, link-local, malformed and mixed DNS responses. The browser transport diagnostic records reachable=false and client-only verification instead of claiming success or opening any private server connection. The authenticated client accepts only that exact diagnostic; all other TLS/DNS/HTTP failures retain their behavior. Configured separate origins, TLS, cookies and VNC auth are unchanged. Boundary tests cover refused address classes and malformed hints; a desktop/mobile browser journey verifies private viewer mounting while connection retry stays read-only. Both isolated local verification and hosted CI now compile with the same synthetic viewer hostname; the new iframe case no longer relies on an inherited deployment hostname. Production install/update configuration is not overridden by this fixture.
2026-09-18 — Resolve release review on Node support and browser retries
The dependency toolchain now requires the same supported Node range everywhere: 22.12+, 24.x or 26+. Package engines, early installer checks, the independent doctor check and install documentation agree; boundary tests exercise both installer and runtime predicates. The current Node runtime is not changed. An unsupported newer runtime is refused rather than silently downgraded by the installer. The verified installer-core checksum is updated with its source.
Camoufox connection retry now creates a fresh read-only connection attempt rather than posting a power mutation. Readiness reports each observed service state and ends as soon as the browser stops, so the UI does not retain a stale running state after a lease expires. Unit and synthetic desktop/mobile browser regressions prove repeated retry sends no power POST, TLS failure fetches no VNC credential, and an observed stopped browser returns to the start panel. Authorization and rate limits are unchanged.
2026-09-18 — Keep MCP target controls locked until their first inspection
PR release verification caught the mobile MCP journey leaving Use project disabled after an early fill. The installation hook originally rendered busy=false with no snapshot, then disabled the controls on a deferred initial inspection. Start busy instead so there is no initially interactive, uninspected target. Mutations still require an inspected revision; backend authorization, target selection and all existing assertions are unchanged.
A regression reproduces the incorrect first-render state for host, named and path targets. The browser journey now holds the initial inspection request, verifies disabled controls, releases it, checks readiness and the entered value, then performs the same real install/uninstall flow across desktop, portrait and landscape. No retries, timing sleeps, coverage reductions or skipped checks hide the original CI failure.
2026-09-18 — Reconcile the refreshed production dependency PR
The final PR audit found that the production update had advanced after the combined security/browser candidate was prepared: its Anthropic SDK target was now 0.125.0, not 0.124.0. Preserve the original PR ancestry and retain the verified paired Vitest/coverage 5.0.0, Node 22 typings, PostCSS, action pins and scanner fixes while applying only that remaining SDK delta. Regenerate the Bun lockfile instead of accepting the older PR lock wholesale; no transitive package or runtime provider configuration changes. The published SDK release notes were checked and targeted provider tests passed. Main integration, full gates and production status remain separate release evidence, not assumptions derived from this dependency edit.
2026-09-18 — Inspect Organization fixture permissions and bytes on one descriptor
The combined release's hosted CodeQL scan identified a filesystem race in the new Organization flow test: it inspected a pathname with stat and then opened it separately for reading. The fixture now opens once without following a final symlink, checks the same descriptor's permissions, reads those bytes and closes in finally. All persistence assertions remain; runtime Organization behavior, scanner policies and ignores are unchanged.
2026-09-18 — Reconcile pending browser and dependency work with Organization main
Preserve the released Organization project-flow implementation while merging the previously verified dependency and Camoufox candidates. Only the generated changelog and historical progress entries conflicted; both source histories are retained. The combined commit must pass its own release gates. Local reconciliation does not imply a remote PR merge or deployment.
2026-09-18 — Organization-scoped project flow
- The organization overview previously rendered long context notes directly inside unit cards. Keep overview descriptions clamped and put projects, activities, relationships and long notes inside the selected unit instead.
- Add a generic optional
projectFlowto the private organization store with bounded schema, stable node/edge ids, same-unit edge validation, atomic revision-checked CRUD and legacy-unit-edit preservation. Public source contains no operator organization data. - Projects/Seats navigation preserves reporting and execution bindings. Project-flow nodes support details, editing, persistent drag positions, search, focus and explicit connections/deletion; project references do not execute anything.
- Extend the existing organization API/MCP/CLI contract rather than creating a second store or executable workflow. Expand only the organization HTTP body allowance; integration setup retains its original default bound.
- Full verify passed (3,056 tests across 511 files), production build passed, and the isolated browser journey verifies node CRUD, visible directional edges, persistent drags, long notes, real MCP mutation, stale-revision and scope refusal, and desktop/portrait/landscape layouts. The complete release E2E and eager bundle budget also pass. Canvas measurements are preserved separately from server-owned data.
2026-09-18 — Separate Camoufox process health from secure viewer reachability
A running user service and loopback noVNC response did not prove the separate public viewer could negotiate TLS. The Browser app now requests an authenticated, rate-limited transport diagnosis before fetching its VNC credential. The probe uses the existing public-address/DNS-pinned transport, no credentials, no redirects, a bounded wait and short in-flight cache. Anonymous denial is recorded only as HTTPS transport evidence, never as proof of authenticated VNC access. TLS, DNS and upstream failures are readable. Connection failures preserve the service's real running state and expose retry rather than an endless spinner. Power help now acknowledges deployment-configured session limits.
Native GitHub verification now displays the validated account login from the official user endpoint, while still explicitly declining to claim repository permissions. An MSO profile label is not a GitHub account identity. Unexpected payloads and credential reflections never enter the account label; no connection, token or account is replaced.
2026-09-17 — Reconcile dependency PRs as one tested release candidate
The continuation preserved the pending cooldown and lock-fixture fixes and reconciled Dependabot production, PostCSS and pinned CodeQL action changes in an isolated worktree. The PostCSS/React lockfile conflict contained independent nested package entries; both were retained instead of replacing the newer React dependency graph.
The separate Vitest major PRs selected incompatible runner/coverage pairs. Even matching major versions can resolve to different patches, so canonical test and coverage commands now fail early unless the installed versions match exactly. The reviewed Vitest 5.0.0 runner and coverage provider are pinned together, and Dependabot groups future Vitest packages in one PR. A fixture covers both major and patch mismatches. Node typings remain on the .nvmrc baseline (22); a newer typing major is not accepted merely because tsc passes. The existing coverage floors and test assertions are unchanged.
These changes are a candidate, not a production claim. The current main release stays untouched while normal PR authentication, required checks and exact-SHA release verification are pending. No owner exception or direct-main publication is used by this continuation.
2026-09-17 — Keep native dependency updates behind the existing cooldown
The hosted Semgrep scan reproduced a missing seven-day cooldown on the new isolated node-gyp Dependabot entry. That entry now follows the same policy as the existing Bun and GitHub Actions entries. A regression checks every configured ecosystem, so adding another updater cannot silently omit the policy. Scanner rules and severity gates are unchanged; this corrects update configuration without changing the application runtime.
The full gate also exposed a scheduler-sensitive 24-contender lock fixture: its four-second acquisition budget could expire under parallel coverage while the isolated test passed. The fixture retains every contender and all mutual-exclusion assertions, waits for all outcomes before removing its files, and uses a bounded ten-second test-only budget. Production lock deadlines and the short fail-closed denial tests are unchanged.
2026-09-17 — Lock the native build bootstrap without touching the runtime tree
The complete PR/branch audit found open Scorecard finding #136 in the user-local
node-gyp bootstrap. An exact top-level version still allowed fresh transitive
resolution. The helper now installs from a committed npm lock containing integrity
hashes for all resolved packages, with lifecycle scripts disabled. A manifest-hash
cache and private atomic staging preserve existing user-selected cache roots and
never run npm ci against the MSO checkout. Cache validation, failed-install cleanup,
wrong-version and symlink refusal, native-binding checks and the installer's outer
recovery trap are covered. Node, node-gyp's existing version, Bun, privileges, bind
addresses and runtime behavior are unchanged; no scanner suppression was added.
2026-09-17 — Finish the verified branch release and loopback managed-app relay
The release audit reconciled the dormant Workflow/Organization controls, exact artifact history, private-store hardening and bundle work through PR #47 rather than rewriting their source branches. All candidate changes were already gated; this handoff independently rechecked 83 targeted tests, typecheck and current PR checks before integration. Dirty worktrees, stashes, historical alternatives and recovery refs remain preserved; an old branch name alone is not evidence of a missing feature.
The remaining managed-app relay patch was reproduced with a failing reverse-proxy test, then applied from the preserved source after reviewing its two-file delta. Public HTTPS headers can describe an HTTP loopback Next listener as HTTPS; internal managed-app rewrites now correct only loopback transport while retaining the public scheme for non-loopback origins. Regression cases cover localhost, IPv4 and IPv6 loopback, query preservation and unchanged public-host/cross-origin guards. There is no bind-address change, provider requirement or weakening of managed-app isolation.
2026-09-17 — Lock-fixture cleanup prevents accumulated test processes
The branch/worktree audit found orphaned mso-lock-holder shells and sleep children from completed gateway boundary tests. The fixture killed only the forking flock parent, leaving the command and inherited lock descriptor alive after its temporary directory was removed. The holder now uses flock --no-fork with a single Node process; readiness is inside try/finally, and the regression asserts exact PID identity, process exit and kernel-lock reacquisition. No gateway/provider runtime behavior or release guard is changed. Historical process cleanup is restricted to verified orphan fixtures from this conversation's worktrees, not other agents or production processes.
2026-09-17 — Descriptor-pinned Workflow storage hardening
The PR/branch audit exposed default-branch security annotations for Workflow run, graph, version, variable, cache and recipe-archive storage. These stores now reuse the existing owner-root and ancestor-pinning authority, open each file without following links, inspect and read the same descriptor, bound reads against file growth, and atomically write through a pinned parent. Version listing and exact revision lookup both enforce full snapshot filenames, byte limits and matching graph/revision identity. Receipt pruning still reads only bounded metadata rather than parsing every receipt; existing formats, quotas and revision guards remain.
Added real filesystem regressions for symlinks, symlinked ancestors, FIFOs, unsafe permissions, oversized/growing files, mismatched versions and unchanged atomic serialization. The installed node-gyp PATH setup now separates assignment/export so command failures are not masked. Scanner settings, ignores and alert thresholds are unchanged. Passing local tests or scans does not close GitHub alerts: the candidate still requires the normal PR checks and production release path.
2026-09-17 — Recover dormant PR/branch work without overwriting active agents
Reconciled the verified performance candidate, the preserved GitHub OAuth-first preference, the dormant exact-session-artifact history candidate, and fork PR #44's edge/directory improvements onto the current main lineage in an isolated worktree. Newer semantic session labels, script/learning directories, read-only session graphs and VPS-backed Store behavior are preserved instead of taking the older fork files wholesale. Original candidate branches remain recoverable until integration is complete. Active hosted/Hermes and gateway work is owned by other sessions and is not replaced or deployed by this reconciliation.
Historical artifact previews now reapply current host read-root/credential policy, refuse symlink aliases, use bounded no-follow descriptor reads with post-open path identity checks, and compute diffs from the same verified byte buffers. Git blob identity is computed from already-read bytes, eliminating diff/hash-object subprocesses and repository filters during capture. No file body is persisted in the event metadata. PTY access remains scoped to its creating principal. Added denial coverage for restricted paths, symlink escapes and revoked read roots; synthetic test roots explicitly grant only their own read/write access.
The audit records every observed branch, worktree and PR with a disposition. Normal Git cleanup removes only clean, dormant worktrees whose HEAD is already reachable from main; active/dirty/unmerged trees, local environments and referenced dependencies remain protected. A verified private Git bundle and ignored-note backups precede cleanup. The resumed build exposed a broad Turbopack filesystem trace from the artifact reader. Owner-selected files are runtime data, so the three guarded open/lstat path arguments now use the established runtime-only tracing annotation. No files are excluded globally and read-root, no-follow, size and identity checks remain intact. An isolated production build now passes without warnings; the existing targeted artifact/PTY/connection tests also pass.
Full-suite verification caught a compatibility issue in the preserved OAuth candidate: UI ordering must not change the existing API default for an omitted connection source. The API retains its original direct default; the UI explicitly submits the selected OAuth source, preserving both existing callers and OAuth-first presentation. Detailed verification and release status belong to the workflow evidence; this entry does not claim deployment. The expanded browser acceptance now reseeds its synthetic Git history idempotently for all three viewports, waits for complete modal exit/focus cleanup, and asserts node-click selection before inspecting details. It does not replace a failed node click with a compact-toolbar fallback or skip any artifact, redaction, terminal or accessibility check.
2026-09-17 — GitHub OAuth-first Integrations routing
GitHub Connections now present hosted OAuth and provider-owned OAuth/MCP before the manual PAT fallback. The direct GitHub path remains available without capability loss, but it is explicitly labeled as a fallback and recommends an expiring fine-grained token when a direct credential is deliberately required. /integrations now states the no-silent-fallback rule: a failed OAuth/MCP identity must never be replaced by another PAT/principal implicitly. This complements Baton tenant OAuth, which remains a separate user/workspace trust boundary instead of copying customer OAuth tokens into the MSO operator vault.
2026-09-17 — Isolated shell bundle and first-open performance improvements
Reduced eager shell work without removing applications or changing authorization, persistence, native terminal sessions, service-worker recovery, or deployment behavior. Organization's public view now has a lazy facade (the descriptor stays cheap); ReactFlow CSS follows the shared graph canvas rather than the root stylesheet. Search, Inspector, mobile Alfa/Control Center and clipboard presentation load on demand through an effect/state boundary, while lock protection, capture, hotkeys and notifications remain active from startup. The Inspector keeps its selected tab across close/reopen. Settings section bodies are split behind the existing selection and Owner-role checks. App-module prefetch now requires 250 ms of intent, cancels pending requests on leave/blur/close, respects constrained connections, deduplicates loads, and lets expensive app descriptors opt out. The existing local Geist Mono stays available without global preloading.
The exact production build at baseline 866ec61 and the optimized candidate, using the same lockfile and Next 16.3.4, measured eager modern-browser JS at 340,067 → 269,498 gzip bytes (20.8% reduction), shell-entry JS 208,982 → 138,413 (33.8%), CSS 31,158 → 28,887 (7.3%), and preloaded font files 141,020 → 69,652 raw bytes. These are build-manifest measurements, not a claimed page-speed percentage; legacy nomodule polyfills and optional lazy downloads are separate. Added fail-closed bundle limits, import-boundary/prefetch regression tests and a five-shell synthetic browser journey to both the existing isolated build gate and CI. Heavy background-removal assets, quality defaults and runtime/cache deployment layout are intentionally untouched in this phase.
The mandatory Workflow landscape journey exposed an existing readability bug: the unchanged 866ec61 build also shrank a trigger to ~67 pixels in an 826 × 122 canvas. Shared graph fitting now considers canvas height as well as width, waits for measured nodes, cancels pending frames correctly and has a single initial-fit owner. Manual full-graph Fit and zoom remain available. The browser test retains its original size thresholds but samples settled geometry rather than transient animation frames.
2026-09-17 — Preserve strict hosted-release scanner coverage
The Cursor recovery PR exposed existing ShellCheck declaration warnings and Semgrep strict-parser ambiguities alongside one new loopback case pattern. Keep all scanners strict: split command-substitution declarations, use shell parameter expansion for the pinned node-gyp PATH, preserve the Organization usage contract, spell conditional decimal literals unambiguously, and express owner @file handling without nested one-line case statements. Regression tests preserve file paths containing spaces and both IPv4/IPv6 local doctor approval; IPv6 brackets are literal in CLI transport/onboarding rather than a shell character class. No rule exclusions, secret checks, or runtime isolation settings are weakened.
2026-09-17 — Portable executable Forge sandbox bootstrap
A hosted Debian audit found two bootstrap assumptions that prevented the real, network-disabled Forge sandbox from starting: non-GNU awk omitted the ELF interpreter from ldd, and the imported mktemp root retained mode 0700. The bootstrap now uses POSIX whitespace matching and sets only the root traversal mode to 0755, without granting write access or changing the container isolation flags. Regression fixtures cover glibc/musl loader rows and the root mode; the real Docker fixture tests verify source read-only mounts, disabled networking and source-change refusal. The image is still built exclusively from the already-trusted local Node binary and shared libraries, with no version downgrade or registry download.
2026-09-17 — Doctor respects no-systemd and remote runtime boundaries
A live hosted/container audit reproduced a false mso.service not active failure while the loopback runtime, public HTTPS and authenticated CLI were healthy. Doctor now probes actual systemd manager availability before diagnosing its service and never inspects this machine's units for a remote --base. No-systemd hosts continue through the normal health/auth checks without suppressing real failures: health must be JSON identifying a healthy MSO service, and local probes bypass outbound proxy variables. --fix never creates a tunnel, adopts an external supervisor, or claims boot persistence. Added regressions for unavailable managers, inactive real services, remote bases, failed health and unrelated HTTP 200 responses; documented the hosted startup and verified-public-origin boundaries. This changes diagnosis only; no runtime, bind, provider, Node version or existing hosted Hermes/update behavior is replaced.
2026-09-17 — Gateway core becomes deployment/provider/supervisor agnostic
Refactored the gateway reliability boundary without removing the existing Cloudflare lifecycle or process-ownership protections. The new read-only classifier separates local, public, provider and process health from ownership/supervisor state and reports managed-running, external-running, degraded, recovering, stopped or unknown. A configured public origin is healthy only when its structured MSO health identity matches the selected local runtime, including buildSha when present; this fixes the real case where a healthy externally supervised public route was previously displayed as stopped. Added mso gateway status --json, capability-based provider metadata, external duplicate-start protection, and provider-neutral non-mutating doctor diagnostics. Cloudflare remains the current managed/default adapter; external reverse proxies/tunnels are detected but never adopted, stopped or restarted. Existing PID/start-ticks/executable/argv/runtime-instance, atomic private state, update locks and recovery markers remain authoritative. No generic gateway supervise daemon was added because the current external-supervisor model already covers systemd/s6/container/Kubernetes/PaaS ownership without duplicating supervisor semantics. Added provider-neutral regression coverage and a dedicated docs/GATEWAY.md architecture/operations reference.
2026-09-17 — GitHub reference audit and optional app-binding compatibility
2026-09-17 — VPS-backed Store MCP/Skills and explicit host MCP harness
The former custom plugin registry lived only in browser storage while actual project
bindings and reviewed skill installation already had server-side authorities. Store now
keeps its existing Apps surface and adds MCP/Skills tabs; Settings → MCP → MSO to External
reuses the same panels. Previous browser declarations are retained for explicit review,
not silently installed. Host @host and exact-project targets never inherit each other.
Native manage/discover/call tools accept @host, so an external client can discover and
invoke an installed downstream MCP without global tool-name duplication. Check tools is
real paginated native discovery. The skill API reuses reviewed CLI payloads and its local
root, enforces owner access/revision checks and refuses modified/unmanaged/extra/symlink
content before deletion. Remote MCPs remain connection installs, not SaaS downloads;
shared runtimes and provider credentials are not uninstall-owned resources.
Verification is recorded in the release workflow: actual temporary-filesystem install, update/removal, stale revision and unsafe-content refusals, dynamic stdio dispatch, secret-scrubbing, post-uninstall denial, owner API and shared UI contracts. CLI/API parity and synthetic browser release journeys were updated with isolated skill state.
Audited the saved OpenAI GitHub 0.1.12-5f7cd798dc99 package. The snapshot is package/interface metadata only, so no unobserved PR/issue/CI action semantics were invented. Its .app.json provides a concrete compatibility correction: GitHub binds an exact connector_* identity with required:false, while MSO's OpenAI plugin checker previously accepted only asdk_app_* and required every dependency to be true. Added a tested app-binding validator that accepts registered-app, connector and documented template binding identities plus boolean required/optional state; authorization behavior is unchanged. Also made optional capability fallback explicit in architecture and /mso: fallback may change transport only through an already-authorized, explicitly selected identity and must never silently switch principal, credential source, or provider-owned OAuth/MCP into a local key. Updated the living plugin-reference matrix and recorded that GitHub strengthens the target-aware resolver/dependency-contract candidates but does not yet justify a generic dependency graph or universal fallback engine.
2026-09-17 — Plugin Management reference audit and extension taxonomy
Audited the local OpenAI plugin-management 0.1.0 package plus its installed tool contracts. The recurring improvement is model-facing capability selection and terminology, not a reason to collapse MSO authorities: Skills remain trusted instructions, Project Plugins remain exact-project capability packages, MCP remains the tool protocol, Integrations remains the credential authority, Apps remain workspace UI, and Managed Apps remain external service runtimes. Added the living docs/PLUGIN-REFERENCE-MATRIX.md, made that taxonomy canonical in docs/ARCHITECTURE.md, and updated the main /mso skill to reuse existing native/project/integration capabilities before adding a new plugin. No tools, scopes, credential behavior, low-level primitives, or descriptor schemas were removed or added. Generic suggestion state, dependency graphs, platform-style permission inheritance, and universal lifecycle/postcondition engines remain cross-reference candidates rather than one-plugin abstractions.
2026-09-17 — ChatGPT List surface and OpenAI app scaffold
Added render_mso_list + ui://mso/list-v1.html as the lightweight collection surface between Block and Page. Data tools remain headless; the model first fetches/filters structured results, then renders at most 40 selected items as list/grid with local search, bounded metadata and user-approved follow-up actions. The widget has no network/tool-call path and cannot execute mutations. ChatGPT now exposes 113 transport tools while retaining the strict 96 KiB internal descriptor budget through scanner-only summary compaction; full MCP descriptions and runtime schemas remain unchanged. .app.json is now a valid empty registered-app scaffold referenced by the compatibility manifest, with skill checks rejecting malformed or placeholder mappings.
2026-09-17 — OpenAI plugin skill contracts + local validator registry
- Implemented additive structured
contract.yaml+agents/openai.yamlbundles for all 13 official skills, a portable root.codex-plugin/plugin.json, local artifact validators, compact contract-aware skill discovery, and full-MCPmso/actionContractlifecycle metadata on selected stateful tools. - WHY: make routing, target, source-of-truth, validation, confirmation, concurrency, and OpenAI presentation machine-readable without replacing MSO's stronger trust/provenance, bounded scopes, CAS/revision guards, workflow isolation, evidence receipts, dynamic project MCP boundaries, explicit confirmations, or shell escape hatch.
- Kept all 112 ChatGPT actions and the 97,350-byte compact action profile; per-tool action contracts stay on the full MCP descriptor while OpenAI receives the structured workflow policy through skill resources, preserving the scanner budget without hiding capabilities.
- Re-reviewed the refreshed Shopify reference implementation: adopted its offline/local schema-validation and per-skill OpenAI descriptor ideas, but did not copy external prompt/code telemetry. The live OAuth
/mcpapp remains a separate connection from the skill-only Codex/OpenAI plugin package.
2026-09-15 — Workflow edges and Directory close the remaining n8n-style interaction gaps
Workflow Graph v2 already had the real server-native pieces—schedule/webhook triggers, cache, memory, sessions, capability tools, project functions/MCP, organization-seat agent routing, run history, versions and variables—but two editor gaps still made the surface feel incomplete. Connections now persist an explicit Auto / Solid / Dashed presentation, an Active execution toggle, directional arrows and a guarded reverse-direction action. A disabled connection stays visible for documentation/debugging and is recorded as disabled in run receipts, but it cannot be re-enabled by source execution, affect cycle/tidy topology, or accidentally promote its target into a new executable root.
The Workflow Directory now exposes the five runtime registries users actually work with: Tools, Workflows, Sessions, Projects and Skills. Project/skill metadata is added only for Operator/Owner sessions so the existing Viewer boundary is not widened. The web UI and Directory nodes continue to reuse MSO's project/Skill SSOTs rather than introducing another catalog. Release E2E covers the 5/5 graph controls, responsive canvas/drawers, minimap content, project/skill directory, edge style/active/reverse controls, real cache/memory/session/directory execution and Organization responsiveness.
2026-09-15 — Shell-native server status + CI security fixes
The global floating Live server · owner badge is gone. MSO now contributes one systemStatus feature into AppShell and each shell places that shared status in native chrome: macOS menu bar, Windows taskbar, iOS/Android top status area, and the Dashboard header. Auth/session logic remains single-source in the consumer feature; generic AppShell owns only the slot placement.
Security CI root causes were fixed rather than suppressed: the SI-Coder migration shell bridge no longer triggers ShellCheck SC2066, and SI-Coder package discovery now opens package.json once with O_NOFOLLOW, validates the opened descriptor, and reads through that same descriptor, removing CodeQL alert #126 (js/file-system-race).
2026-09-15 — Integrations removes its final local layout constant
The compact master/detail threshold is no longer written directly in Integrations styles. Generated @container rules now interpolate SETTINGS_COMPACT_MAX from the shared presentation responsive contract. This keeps the unavoidable query value in one reviewed SSOT while provider content, setup and Transfer source files contain no local color, length, typography, radius, spacing or breakpoint constants. The style contract tests both generated CSS and the feature source files to prevent regression.
2026-09-15 — Integrations content is fully token-driven
The Settings-style Integrations shell and its content pane now consume one semantic visual contract instead of feature-local colors, dimensions, radii, typography, or spacing constants. Provider cards, credential rows, menus, setup forms, Transfer & backup, status pills, buttons, and empty states use shared background/card/primary/muted/border aliases plus the MSO widget spacing/type/radius tokens. A regression test rejects feature-local hex/RGB, px/rem visual lengths, numeric font weights, and literal white/black in Integrations styles; only the structural container breakpoint is exempt because CSS custom properties cannot parameterize media/container-query conditions.
The native same-origin Integrations iframe now receives the active AppShell palette, accent/foreground, sidebar, shadow, radius, shell font, and root font scale at load time and whenever shell theme/preset styles change. This removes the previous split where the window/sidebar followed MSO but the generated content retained its own fallback appearance. MCP Page continues to map host style variables through the same semantic aliases.
2026-09-15 — Integrations adopts the Settings sidebar/detail layout
Integrations now uses the same navigation grammar as Settings instead of its own toolbar + nested provider rail. Desktop uses a searchable 224px sidebar grouped into Connections and Manage, with a bounded 48rem detail pane; below 600px the same sidebar becomes an accessible drawer with Escape/backdrop close behavior. Credential owner selection stays in the sidebar, section state persists across owner changes, and connection counts are decorative so accessible button names remain stable.
Transfer & backup now mounts inside the right detail pane rather than replacing the whole manager, so the sidebar remains present while exporting/importing. Credential setup remains an intentional secure drill-down. Provider CRUD, raw/encrypted export, copy/share, routing and project-MCP behavior are unchanged. Browser coverage exercises 320–1920px, light/dark, drawer navigation, persistent section state and inline transfer.
2026-09-15 — Integrations progressive UI + password-gated credential export
Integrations keeps provider actions simple inside the selected detail pane while navigation lives in the Settings-style sidebar. Connection cards still distinguish linked Share from independent Copy to another owner.
Transfer & backup adds All/Custom selection with an owner → provider → connection checkbox tree. Encrypted JSON remains the recommended secret-bearing backup; metadata JSON is value-free. Deliberate raw JSON/.env downloads require Owner role, the current MSO password, an explicit plaintext acknowledgement, a 90-second one-time grant bound to the selection, no-store response headers and audit metadata that never contains the password or exported values. Bulk imports remain preview-first/create-only. Agent guidance now requires checking Integrations before asking for a new credential.
2026-09-15 — Original-byte MCP transfer final hardening
fs_upload_fileis content-idempotent and fail-closed on filename conflicts by default; deterministic rename and SHA-guarded replacement are explicit.- PNG/JPEG/WebP require bounded full decode; JSON requires fatal UTF-8 + parse; ZIP requires an EOCD structure before write.
fs_export_filenow exposes owner-bound ephemeralmso-file:///…resources;resources/readreturns exact original blobs only to the same MCP principal + conversation session while browser temp-share remains a separate convenience.- Public schema changes require ChatGPT Scan Tools / Refresh and a new chat before external-client acceptance testing.
2026-09-15 — Project plugins are opt-in, isolated installations
MSO Access now treats SI-Coder and Batonly as available, not pre-installed. A fresh project has no plugin binding; exact-project .mcp.json is the installation authority and discovery never inherits parent/sibling bindings. The Settings wording is now Catalog → Project install with explicit Install / Update / Uninstall actions.
Batonly joins SI-Coder as a first-class reviewed project plugin. Its project binding stores only plugin: batonly, MSO credential authority, and an exact named connection reference; endpoint/token remain in the reviewed catalog and Integrations. Inspecting an alias no longer counts as plugin installation unless its returned plugin identity matches.
This preserves three separate layers: host MCP access, reusable MSO Integrations credentials, and project-local plugin bindings. Installing or removing a plugin from one project changes neither standalone SI-Coder nor Batonly data nor another project.
2026-09-14 — Original-byte MCP file export + explicit ChatGPT import matrix
The upstream MSO file-transfer audit is now implemented instead of remaining a read-only finding.
fs_export_file exports one original file through the existing authenticated temporary-share store:
READ-root/credential guards and O_NOFOLLOW remain authoritative, bytes are not decoded or
recompressed, SHA-256 is returned, and the approved-device download expires after 15 minutes / five
downloads. ChatGPT import is now an explicit PNG/WebP/JPEG/JSON/ZIP matrix with format validation;
generic octet-stream is accepted only as a transport response for a known declared/inferred format,
not as a bypass. Generic MCP Azure Blob trust remains exact-only through optional
OS_MCP_OPENAI_FILE_HOSTS, while *.oaiusercontent.com is trusted directly. The rotating
oaisdmntpr<region> Azure family is accepted only when OAuth registration proves a
chatgpt.com callback; a self-declared ChatGPT client name does not grant that exception.
Derivative MSO projects remain unchanged until this upstream contract passes release verification.
2026-09-14 — Integrations is a first-class shell app and SI-Coder worktrees are detected safely
2026-09-14 — Preserve dedicated embed endpoint from concurrent release
The concurrent /integrations/embed fix is retained as a same-service alias alongside
/integrations/manager; both use one nonce-protected response helper and same-origin framing.
The shell keeps the tested loading/retry implementation and /connections deep link.
Standalone setup/API routes remain compatible and keep their default deny-framing policy.
2026-09-14 — Reconcile parallel Integrations work
The two concurrent implementations are consolidated into one integrations feature slice,
not two app descriptors or managers. The native window uses /connections and the internal
manager endpoint; the earlier embed=shell compatibility alias is retained with same-origin
framing only. Both standalone deny-framing and package-entrypoint spoof regression tests
remain. An explicit invalid MSO_SC_BIN never falls back to another user's/default CLI.
The native Integrations workbench existed as a browser/Page/CLI surface but was absent from the
OS-shell app manifest, so it could not behave like the other dock/launcher features. Integrations
now has its own feature-slice AppDescriptor, is pinned by the MSO consumer manifest, and reuses
the canonical /integrations manager instead of duplicating credential state or actions. The
ordinary browser route remains anti-frame (DENY / frame-ancestors 'none'). Only the dedicated
/integrations/embed shell route permits same-origin framing (SAMEORIGIN / frame-ancestors 'self');
the global header policy explicitly overrides DENY only for that route, so the new window does not widen
cross-origin framing policy.
Local SI-Coder migration discovery previously required the version-reported source path to contain
si-coder-agent. The installed SC 0.9.8 currently resolves to a legitimate worktree named
~/worktrees/sc-flow-merge-main, so that name check produced a false unavailable state.
Discovery now validates that the resolved SC executable lives inside the absolute checkout reported
by sc version --json, treats an explicit MSO_SC_BIN override as authoritative, and additionally
validates the exported Integration Bundle v1 producer/mode before reading metadata. Arbitrary
binaries that merely claim another source tree are rejected. The bridge remains optional,
metadata-only for automatic discovery, and is still an explicit snapshot/import path rather than
live bidirectional credential replication. The real installed probe now reports 10 users and 72
named connections without exposing credential values.
Verification: the focused Integrations/SC/security-capability suite passed 12/12, TypeScript passed,
repository-wide ESLint passed with zero warnings, and the safe out-of-tree mso build completed its
isolated Next production build plus mandatory release journeys. Browser release checks passed the
reviewed desktop/mobile demos, 45 MCP Page assertions, production smoke 4/4, public responsive
journeys, Sessions/MCP accessibility, Add MCP/project-flow CRUD, and authentication/role/file/exec
boundaries. The live checkout was not rebuilt in place during verification.
2026-09-14 — Project MCP HTTP discover falls back on JSON-RPC -32601
2026-09-14 — Native Integrations shell and project-scoped SC activation
Before: Integrations had a standalone page but no app descriptor/catalog entry; plugin
registry declarations looked disconnected from runtime; SC detection assumed its checkout
folder was named si-coder-agent. After: a pinned native Integrations shell window reuses
the existing manager, reviewed built-ins can be explicitly bound to exact projects from
Settings, and package/bin identity accepts legitimate renamed worktrees without invoking
an unrelated system sc. Managed SC account/status/verification calls resolve through MSO
Integrations; standalone SC remains unchanged and no credential synchronization is applied.
The registry distinguishes configured from verified. Existing project MCP discovery/call
tools remain the verification path; no new privileged browser execution endpoint is added.
Batonly remains project/task/evidence authority. See docs/INTEGRATIONS.md for the managed
binding contract and the explicit limits on SC's exposed managed tool surface.
project_mcp_tools probed modern server/discover and treated only HTTP 400/404/405
as unsupported. A legacy-only HTTP MCP that answers JSON-RPC method-not-found on HTTP 200
— the usual JSON-RPC wire — entered the fallback branch and then threw -32601 because
the status was not 4xx. HTTP project MCP now treats -32601 and modern-protocol refusal
(-32022) as unsupported regardless of HTTP 200 vs 4xx, then continues with legacy
initialize + tools/list. Malformed-request codes still fail closed. SSRF, exact
endpoint match and credential scrubbing are unchanged. A Batonly-like server does not
need to implement server/discover.
2026-09-13 — About version detection without systemd
An installation on a non-systemd host was thirteen commits behind origin/main, but Settings returned an empty status before querying Git and then labeled it Up to date. Read-only version discovery now runs independently of automatic-restart eligibility: running, checkout and latest fetched SHAs remain visible, while unsafe restart actions stay blocked with the supported terminal update path. A failed fetch is not Current; HTTP/auth/network errors leave a visible retry panel instead of disappearing. Overview also has a direct software-update action. No version number is fabricated when new commits ship under the same application/CLI semver. Detached installs still refuse mutation, while reporting the actual available changes for recovery.
2026-09-13 — README MCP entry point and practical how-to
Before: the product README linked general docs, while MCP onboarding was spread across long references and the ChatGPT refresh sequence still named an obsolete tool count. After: the README has a direct Use MCP entry point and explains inbound/outbound access; a Bahasa Indonesia how-to covers owner/HTTPS setup, least-privilege OAuth, client commands, first prompts, exact workflow correlation, dynamic project MCP discovery and troubleshooting. SI-Coder remains optional; registry declarations are explicitly not activation or credentials. Current references/index link to the guide, and snapshot verification uses the generated catalog rather than another hand-maintained count. The existing Page guidance now distinguishes reviewed exact-origin embeds from arbitrary URLs. No MCP schema, permission, or runtime code changed. Validation: documentation/catalog/comparison checks, both JSON examples, shell syntax and 14 targeted client-guide/direction/integration-contract tests pass. Full repository gates remain required by the normal ship path. External-client snippets are source-checked guidance, not a claim that new OAuth accounts were connected end-to-end.
2026-09-12 — Native scrollbars follow the active theme
Direct inspection in the owner browser found a white native Settings scrollbar inside the dark shell. Global browser color-scheme now follows the existing theme attribute; scrollbars use the shared secondary-text token and forced-colors keeps system rendering. The global focus fallback also derives its corner radius from the selected preset. Release browser journeys check light/dark native controls and forced-colors behavior.
2026-09-12 — Reviewed project previews, responsive workspace and durable session recovery
The owner reported empty Sessions and insufficient embedded UI improvement. Live diagnosis found exactly 1,001 presence leases against a 1,000-entry read validator, causing both active and saved monitors to return HTTP 400. Pruning now happens after insertion; only the known historical overflow shape is accepted and normalized without deleting sessions. The artifact path also confused 2,048 prepared exec folders with 128 populated artifact sessions, blocking new screenshots despite only nine populated sessions. Registered-session quota now counts populated manifests with bounded reads; original byte/ownership/retention guards remain. Screenshot automation writes owner-only files before registration. The repaired reader recovered 7,039 saved records in ~0.51 s on this instance. Settings starts with saved history, offers cross-page safe metadata search, and retains a clearly marked last observation during transient polling errors.
Page v15 uses a shared type/spacing/control/radius/focus/scroll contract, standard host style overrides, a compact container-responsive selector, and a native service selector on narrow layouts. It reuses existing session/artifact/project tools for more native views, unboxes nested data consistently, and ignores stale responses after navigation. Reviewed project demos now honor registry iframe/remote policy with exact CSP origins, fixed sandbox and direct/browser fallback. The authenticated cockpit remains unframeable. OpenAI's stricter nested-frame review is preserved, not treated as a ban on requested previews. MCP 1.14.0 / toolset 2026.09.12.3 versions the refreshed Page contract.
2026-09-12 — Exact-origin Page browser fixtures
The hosted Semgrep gate flagged a wildcard postMessage target in the new browser host simulator. Fixture messages now use the exact reviewed test origin and check the sending frame identity. The Page regression and pinned strict Semgrep pass; production host-bridge behavior is unchanged.
2026-09-12 — Full-height MSO Page and shared brand
The embedded Integrations report reproduced the old 48% legacy height cap. Page v14 now uses the standard MCP Apps fixed/maximum container height before legacy globals, with a 680 px fallback and one content scrollport. Resize notifications cannot feed the current iframe viewport back into a smaller height. Standard host theme, safe areas and supported display modes are honored; fullscreen stays user initiated.
Following the installed SI-Coder sc-fe workbench contract, Page uses readable controls, restrained separators and a compact header. Page, Block v3, native Integrations and shell use the existing public MSO logo instead of M. Shared manager styles keep both surfaces consistent. The browser regression covers small initial frames, fixed/flexible resizing, mobile widths, themes, Add MCP and fullscreen and runs inside the release gate. Current UI references now describe the iframe-free runtime and actual resource aliases. MCP 1.13.1 / toolset 2026.09.12.2 versions the resource refresh.
2026-09-12 — Hosted flow security checks
The hosted pipeline identified a ShellCheck usage-variable warning and a strict Semgrep parser limitation on compact Bash case statements. Flow CLI cases now use ordinary multiline syntax and a bounded usage fallback. Shared project containment is expressed at the filesystem sink, flow manifests use approved canonical paths, and status waits reject noninteger/out-of-range durations before allocating a timer.
2026-09-12 — Dynamic project MCP and reusable provider flows
Added versioned project automation, shared CLI/MCP execution, durable idempotency receipts, provider-neutral sessions, Add MCP in native/embedded integrations, and safe project asset promotion. HTTP/SSE discovery is incremental, auth-bound and paginated; rich downstream results retain image/audio/resource blocks. Modern 2026-07-28 requests coexist with legacy clients. Existing MSO capabilities are retained, with automated compact-catalog byte and official metadata checks. Session enumeration no longer drops records beyond 5,000; active workflow checkpoints avoid rewriting recipe history per event. Nonzero exec results now count as failed outcomes. See automation contracts and limits.
2026-09-12 — Hosted history scan and security inventory readiness
The hosted checks for PR #41 exposed two distinct failures not covered by the earlier local release report. The pinned, full-history Gitleaks command reproduced two findings in the SC-sync test introduced on September 9: synthetic in-memory values, not production tokens. Only those two historical commit/path/rule/line fingerprints are reviewed exceptions. Current fixtures now generate deterministic synthetic values, without broad exclusions or rewriting shared history.
The push inventory and the Scorecard follow-up both ran before CodeQL SARIF was available; the later CodeQL-triggered inventory passed for the same commit. The inventory now supports an explicit bounded readiness wait and exact requested SHA. Trigger-specific concurrency keeps push, CodeQL and Scorecard follow-ups from evicting each other. It polls only missing/stale CodeQL evidence and still fails on timeout, access denial, malformed evidence, analysis failure, branch movement or any open finding. Negative regression tests preserve those boundaries. Hosted results, rather than local build success alone, determine CI completion.
2026-09-11 — Fresh-install MCP exec default and stable Cloudflare gateway baseline
Fresh installs now write OS_MCP_ENABLED=1 and OS_MCP_MAX_SCOPE=exec beside the generated owner
password/session secret in the private 0600 .env.local. This is an intentional security-default
change: MCP remains OAuth/bearer protected, but a bearer granted exec can run remote commands as
the MSO service user. Existing installations are not migrated in place; an existing .env.local,
including its secrets, MCP ceiling and OS_PUBLIC_ORIGIN, is left byte-for-byte under the installer's
existing preservation guard. Administrators can opt down to write/read before reconnecting a
client.
The stable-public runbook now treats a named Cloudflare Tunnel plus custom HTTPS hostname as the
default production path while preserving the loopback 127.0.0.1:4005 bind. Quick Tunnels remain
preview-only and are explicitly forbidden as OS_PUBLIC_ORIGIN. The docs pin the dedicated ingress
shape, proxied cfargotunnel.com CNAME, old-provider cutover fallback, Cloudflare nameserver path,
and mail-safety rule that MX/TXT plus autoconfig/autodiscover/DKIM CNAMEs remain DNS-only. Device
approval/origin-change notes, no-systemd mso web fallback, managed-app prerequisites and private
provider-token handling are documented alongside the new default. Installer/docs contracts guard the
fresh defaults and update-preservation boundary.
2026-09-09 — Session persistence and auth-sensitive cache resilience
A same-day repeated-login report was reproduced as a client-state resilience problem rather than
a rotating signing secret. The production .env.local still holds the same 64-character
OS_SESSION_SECRET across service rebuilds, while the service restarted repeatedly during active
development. The browser session probe previously converted any /api/auth/me failure —
including a restart-race 502, network error or malformed temporary response — into status=out.
That made a still-valid signed cookie look logged out/mock until a later probe, encouraging an
unnecessary password login. The client now changes to signed-out only after an authoritative
successful authenticated:false response; indeterminate failures preserve the last verified
snapshot. It reconciles immediately after SSR and again on focus, visibility, BFCache pageshow
and reconnect, without reintroducing a loading wall. Explicit logout is unchanged.
Cockpit HTML/RSC navigations now carry an explicit private no-store, zero-age, must-revalidate
policy plus no-cache compatibility headers and Vary: Cookie. The policy is request-shaped so it
does not overwrite immutable/cacheable static assets or API-specific response headers; the service
worker continues to cache only its explicit icon/manifest allowlist. SESSION_EXPIRY_HOURS remains
intentionally bounded at 24 hours by default because an MSO session grants live host control; this
change fixes false logout/cache drift rather than creating an indefinitely renewable login. Focused
probe/provider and proxy regression tests cover transient failure preservation, explicit logout
resolution, immediate reconciliation wiring, document/RSC no-store and static-asset exclusion.
2026-09-09 — Explicit SC credential synchronization
User reports existing SC credentials absent from MSO Integrations. The prior transfer discovery
was metadata-only. Added an owner-local, preview-first synchronization command using SC's
installed connection API and MSO's existing locked store, field registry and validation.
It imports direct named connections, fills compatible empty metadata, preserves existing
credentials/defaults, isolates conflicts under sc- aliases and keeps shared connections as
references. Old DOKU Checkout and MCP Client ID fields map to their distinct native methods.
Unknown fields, external authorization, unresolved shares and conflicting aliases fail closed.
Secret values remain in process memory and the private store; output is metadata only.
An owner-only backup precedes application. Repeating the current snapshot changes no connection.
This is an explicit local snapshot synchronization, not automatic bidirectional replication.
MSO retains standalone operation; SC remains optional and unchanged.
Live evidence: all 65 SC connections across nine users are represented; 48 added, 15 filled, two unchanged. MSO now lists nine users and 74 connections including its existing entries. Readback and repeated preview pass; imported Batonly GitHub authenticates through live MSO. SC has no legacy profile fields; its sole Composio connection is empty, so synchronization cannot supply Batonly's missing Composio Project API key. Five isolated regression tests and typecheck/lint pass. The release pipeline records the remaining repository-wide gates.
2026-09-09 — Complete Semgrep parser coverage
2026-09-09 — MCP Sessions dashboard and handover reference
Added the third MCP tab for six-card session pagination, exact-session readable event logs, active versus stored filters, receiver observability, and a copyable structured handover guide. Active refreshes read only records with a valid presence lease, avoiding full transcript-store scans. The Owner dashboard reuses durable session/presence records; model-facing same-principal messaging remains unchanged. Only allowlisted redacted metadata/events leave the monitor. Keyboard tabs, mobile reflow, pagination, error recovery, scope refusal and redaction receive regression coverage. The handover format is documented message content with existing request/ reply correlation and CLI resume, not an implicit transfer of hidden context or permissions. Validation: 2,701 tests and four production smoke tests passed without skips; required browser journeys cover desktop, portrait, and landscape, including the session dashboard and handover guide.
The remaining forty parser diagnostics are resolved through explicit multiline Bash case arms, quoted parameter-error words, parser-compatible arithmetic and non-truncating append-open lock descriptors. Permission masks retain octal interpretation through validated conversion; process stat parsing retains its last-closing-parenthesis boundary. TypeScript import types are named aliases, JSX ampersands are entities and embedded-script regexes use equivalent escaped less-than literals. Two CLI responsibilities move into focused sourced modules with fixture inventories updated. No Semgrep rules or source files are excluded; both CI and the full security entrypoint now use --strict --error so parser diagnostics block completion. This supersedes the earlier documented scanner limitation.
2026-09-09 — Gateway release handshake under CI scheduling
The final GitHub run exposed a remaining startup race: the held child already carries target argv, so command matching could acknowledge it before it consumed its release gate. Matching now refuses that exact launcher. Quick URL discovery pins the spawned PID/start ticks while wrappers exec; final readiness still requires exact executable/argv before state commits. The concurrent-start regression delays URL publication after interpreter exec, while checking one tracked live tunnel and successful cleanup. No timeouts, skips or identity checks were weakened to obtain a pass.
2026-09-09 — Runtime build boundaries and mobile setup follow-up
Deployment log inspection caught sixteen additional Turbopack warnings. Instrumentation now places Node-only imports inside explicit positive runtime branches, following the Next instrumentation contract (https://nextjs.org/docs/app/guides/instrumentation). Host state, credentials, external Git metadata and installed executables are explicitly runtime-only filesystem inputs rather than traced application assets; existing authorization, containment, size and symlink checks remain intact. The release build now rejects warning output instead of discarding it on successful compilation. MCP setup leads with numbered actions and puts optional display metadata below them; copy text wraps at word boundaries on narrow screens.
A required PTY test exposed an exit/data ordering race under full-suite load. Its harness now waits for both successful process exit and the final quit payload, preserving the real-terminal assertion instead of resolving a partially drained transcript. Semgrep 1.174.0 and the latest 1.176.0 both report zero findings but forty parser diagnostics on valid Bash/TypeScript/JSX; this remains a scanner coverage limitation, not evidence of complete SAST coverage. No scanner excludes or suppressions were added.
2026-09-09 — Zero-warning quality gate and layered MCP settings
User review found MCP confusing despite the earlier release. Live public inspection reproduced an endless MCP loading placeholder after unauthorized access. Owner setup mixed client guides, transport details, access tokens, catalog signatures and audit activity in one scroll. MCP now starts with a task index and drills into client selection then one guide. Connection details, connected-app management, audit and tools each have a separate view and explicit return path. Signed-out users get a direct Owner login preserving the MCP destination; delegated users retain the Owner boundary. Requests are bounded and failed activity never masquerades as no events. Disconnection requires an inline confirmation; active access and expired/revoked history are separated. Refresh acknowledgement explicitly remains a browser-local reminder. Settings icons use theme tokens; navigation and copy targets are larger and clipboard failures are visible. Manual OAuth copy now matches the implemented one-hour access / rotating refresh contract.
All eleven file-length warnings are resolved by responsibility-based extraction, including session creation/mutation/summary, filesystem credential/recursive policy, write/exec catalog declarations, CLI local commands/help, device locking, widgets, and focused test suites. Filesystem containment checks remain in their original sink branches. The lint release gate accepts zero warnings and the physical-line architecture ratchet is reduced. Secret tests use real disposable synthetic files; Forge Docker tests execute unconditionally with the official locally built sandbox. Four live HTTP smoke tests run as a required separate production suite inside release verification and fail on missing configuration. No tests are removed or disabled to get a green report. Browser regression coverage exercises MCP owner/public navigation, client selection, cancel/revoke, error/retry, mobile reflow and automated accessibility.
2026-09-09 — Audit hardening and required browser release journeys
The audit found outdated security dependencies, implicit command retargeting, historical connection checks presented as current health, and an indirect sign-in path. Patched dependency floors retain the existing stack. Explicit invalid cwd now fails before exec/job/PTY launch; successful one-shot results expose their resolved cwd. Connection doctor pins credentials and records a bounded result for that exact revision; rejected access and unavailable providers no longer display an old green Verified state. Credential rotation and later checks reject stale results.
Integrations now links directly to login with a validated same-origin return destination, refreshes cards after Verify, uses embedded provider SVG marks where available, and exposes setup instructions without two collapsed levels. Signed-out desktop entry labels mock data persistently; Settings avoids fetching owner AI configuration for anonymous/delegated visitors. Standalone heading hierarchy and verified text contrast are corrected.
The release build is followed by synthetic browser journeys for desktop, phone portrait and landscape, login/return, a local provider that changes from success to 401, state after reload, harmless file/exec operations and live device-role demotion. Public Integrations also runs automated accessibility checks. All fixture state is disposable; no production credentials are used. Unit test environment baselines and two-instance resource/CSP tests prevent host configuration from changing default-test expectations. Coverage floors follow the observed baseline; palette regressions now fail; strict dependencies are checked daily in CI. Initial validation: full bun run verify passed with 2,668 tests (7 environment-dependent/legacy skips), 44.02% line coverage, zero lint errors, and zero palette contrast failures. The exact committed production build passed all required browser journeys at 1363×936, 390×844 and 844×390, including automated WCAG checks on public Integrations. Strict dependency audit found no high/critical advisories. Eleven existing file-length lint warnings remain. This is synthetic-provider/browser evidence; it does not claim live third-party OAuth, physical-device/screen-reader, load or disaster-recovery coverage. The canonical ship gate repeats verification before deployment. Production screenshot review additionally exposed a mobile mode badge overlapping the Settings title; compact mobile placement and a required geometric non-overlap assertion correct that regression.
Security scanner follow-up
Public GitHub CI passed, but separate security gates identified a legacy E2E credential flow, a missing explicit GCM tag-length option, and historical scanner false positives. Native desktop and Preview scripts now run a built app with disposable credentials/stores and explicitly seeded live test preferences; they never read deployment passwords or approved production devices. Authentication refuses redirects. AES-GCM encryption/decryption explicitly require 16-byte tags, with a regression test rejecting truncated tags before import. The history allowlist adds only reviewed commit/path/line fingerprints for synthetic Dokploy keys and DOM maxLength/hidden assignments; no broad rule/path exclusion or history rewrite is used. Chained form assignments are split to avoid new false positives. Local pinned Semgrep reports zero findings (38 existing parser warnings); pinned Gitleaks scans 541 commits with no unignored findings. The seven transfer tests pass. The extended out-of-tree production build also passes required release journeys, native Windows/macOS Files and Settings interactions, and Preview byte-loading/sandbox checks for image, PDF, audio/video, Markdown, CSV, HTML and text; no unexpected HTTP or browser-console errors remain.
Gateway startup identity race
GitHub's concurrent-start test exposed a real startup race: a script launcher can exec an interpreter with the same PID/start ticks after MSO captures its initial executable/argv identity. Persisting that stale identity let a second start treat the live tunnel as absent and create another. After public readiness, MSO now revalidates the exact command and owned process lifetime, captures the final identity, and only then commits state. A delayed interpreter-exec fixture reproduced two live tunnels before the fix; both direct and interpreter starts now require exactly one spawned/live tunnel whose full identity matches the saved state. Login return paths additionally reject paths that normalize into scheme-relative external destinations, including encoded dot segments.
2026-09-09 — Instance portability and MCP privacy boundary
MSO source no longer owns an operator hostname, home path, project root, MCP widget origin, or external Page app. Browser origin comes from OS_PUBLIC_ORIGIN; the MCP Apps sibling origin is derived per installation or overridden with OS_MCP_UI_ORIGIN; reviewed external Page apps are an empty-by-default, bounded MSO_SURFACE_APPS_JSON catalog. Current repository/worktree instructions resolve the active checkout rather than assuming a maintainer home. A repository-wide instance-literal gate now rejects known operator-instance domains/paths across runtime code, tests, docs, workflows, and official skills. Maintainer deployments keep their own public values only in ignored/local runtime configuration.
2026-09-08 — Native desktop Files and Settings
Files now presents Finder and File Explorer names and distinct toolbars, navigation, search, folder colors, selection and status treatments while retaining the shared host API. Windows Settings replaces horizontal tabs with a searchable Fluent sidebar; macOS System Settings gains grouped search and colored categories. App names follow the current shell without changing routes or custom file titles. Running Windows taskbar pins now minimize/restore the front existing window instead of duplicating a multi-window app; New window remains explicit.
Browser checks exposed two underlying issues: home-relative breadcrumbs invented /~ paths, and app sidebars only adapted to the viewport. Home paths now remain home-relative, and the shared sidebar switches to a sheet below 600px of actual window width (including Code's existing sidebar). Windows Enter opens, F2 renames and Backspace navigates back; Finder Enter renames. Settings wallpaper previews now have a real width and resolve Auto to the shell backdrop. Tests cover breadcrumb paths, platform profiles and authenticated/preview browser search, rename, taskbar reuse and narrow-window navigation in scripts/e2e/desktop-native.mjs.
2026-09-07 — Private named connections for modular project MCPs
A project MCP declaration previously supplied only a URL or raw header values, so Baton discovery through MSO returned 401 despite the generic dispatcher existing. The Project MCP integration now keeps an endpoint-bound downstream bearer in the owner-private connection store; repo manifests carry only a named user/connection reference. Exact optional tool grants apply at discovery and call time, connection changes are rechecked, errors/results redact the selected token, HTTP requests time out, and paginated catalogs fail explicitly when incomplete. Token identity and live downstream RBAC remain authoritative; no impersonation or incoming-token passthrough is added. Shared project metadata types replace a copied auth union. See PROJECT-MCP-CONNECTIONS.md for setup and acceptance. The global tool names remain unchanged; compact discovery copy is shorter to retain scanner headroom after the provider enum grows.
2026-09-06 — Dokploy public build env rollout is a bounded native integration operation
The verified native rahmanfakhr / dokploy / default connection can now resolve applications within one exact Dokploy project and update one browser-public build environment variable before queueing a redeploy. The mutation accepts only NEXT_PUBLIC_, VITE_, PUBLIC_, REACT_APP_, or EXPO_PUBLIC_ keys, rejects multiline/oversized values and duplicate target keys, preserves existing server env/build args/build secrets privately, re-reads the application to verify the exact change, and redeploys only when the value changed. It does not expose environment contents or add a generic Dokploy request escape hatch. The mutation stays out of the compact ChatGPT global profile and is reached through the existing native integration_execute surface.
2026-09-06 — Pinned provider DNS supports modern Node all-address lookup
Dokploy credentials already used by Rahman Resources were valid, but MSO's SSRF-safe transport failed before opening the socket with Invalid IP address: undefined. Modern Node http/https may invoke a custom lookup with options.all=true; the pinned callback still returned the legacy (address, family) shape, so Node tried to consume a missing address from the wrong callback contract. The shared pinned lookup now returns a one-element LookupAddress[] in all-address mode and preserves the legacy shape otherwise. Dokploy's live project.all probe now succeeds through the DNS-pinned transport, and the same helper replaces the duplicate A2A loopback pinning callback. No SSRF policy, DNS-rebinding rejection, redirect rule, or credential boundary was weakened.
2026-09-06 — Local SI-Coder migration discovery
Integrations now detects an installed ~/.local/bin/sc through its public metadata-only Integration Bundle v1 and surfaces a create-only Import from SI-Coder action. This is optional migration plumbing, not an MSO runtime dependency: no SC store internals are read, no secret values are auto-copied, existing MSO identities are preserved, and encrypted direct-credential transfer remains an explicit private flow.
2026-09-06 — /integrations becomes the canonical MSO Chat credential command
MSO Agent slash discovery now exposes /integrations and opens the same native Finder-style Integrations surface used by the CLI. A matching official integrations skill is cataloged for /skills and /skill integrations, keeping model-driven work on integration_query, integration_manage, integration_execute, and private integration_setup_open. The older /provider and /providers handlers remain executable for compatibility but are hidden from the slash palette/help so the product has one user-facing credential concept: Integrations. Agent onboarding/runtime hints now point to Integrations rather than the legacy three-provider commands. No credential values enter chat or slash payloads.
2026-09-06 — Final MSO Integrations Finder renderer and TUI interaction model
The first Finder pass exposed a real Windows Terminal/SSH alignment defect: vertical separators were independent content fragments, empty placeholder columns consumed most of the screen, and the frame lacked the normal MSO visual language. Integrations now builds a complete cell-aware frame before painting it, draws connected box borders at fixed column boundaries, reserves the final terminal cell against implicit wrapping, and uses absolute cursor addressing for every row. The responsive pane count is 4/3/2/1 at 132/92/68-column breakpoints, but only real ancestry panes are drawn; no blank Finder columns are reserved.
MSO blue, status colors, section/path/filter chrome, a populated Inspector/Result area and a compact contextual shortcut footer make the screen part of the MSO TUI system rather than a generic monochrome picker. / filters only the active column; selection/query state is remembered per layer; V/R/S/D/N, section keys, transfer shortcuts and help are context-aware. Transfer and Hostinger Mail remain part of the native tree. Presentation state contains metadata only; secrets still enter through the existing private browser/TTY boundary and all mutations use the same Integrations API. PTY acceptance covers 60×20 through 200×50 and treats border continuity/right-edge wrap as release blockers.
2026-09-06 — Integrations adopts the SI-Coder Finder column browser
Bare mso integrations now uses a persistent macOS Finder-inspired column browser instead of replacing the whole terminal with one nested picker at a time. User → provider → named connection remains visible across adjacent columns; opening a connection adds its action/detail column, and new-connection setup extends through source/backend and authentication. Wide terminals show four stable columns, narrower terminals keep the deepest two or three while PATH preserves ancestry. ↑/↓, →/Tab/Enter, ←/Esc and type-to-filter match the SI-Coder navigation model. The lower INFO/PREVIEW/RESULT area keeps metadata and operation feedback in-frame.
This is presentation-only state: the TUI still calls the same native owner API for every read and confirmed mutation, secure credential entry still leaves the terminal for the private form, explicit subcommands are unchanged, and non-TTY mso integrations still emits a machine-readable snapshot.
2026-09-06 — One bounded MCP Page preview per tool result
A real ChatGPT screenshot showed Play Together twice inside one MSO Page result and an inline preview consuming more than the requested share of the conversation. The Page descriptor was publishing both the standard MCP Apps ui.resourceUri and the legacy ChatGPT openai/outputTemplate for the same Page resource while the reviewed app catalog still defaulted Play Together to fullscreen. Page v10 removes the legacy Page binding from render_mso_page and integration_setup_open, defaults reviewed apps to inline, and keeps older Page URIs as read-only cache aliases.
Inline height now derives from the host-provided maxHeight and is capped at 48%, with the Page body owning overflow instead of forcing 360–480 px iframe minimums. Fullscreen and PiP remain explicit controls and keep their prior full-host sizing. Browser coverage proves one reviewed child frame per Page document, one load for unchanged results, inline mode under half of an 800 px host fixture, explicit fullscreen/PiP capability advertisement, source/origin readiness checks, timeout/retry, and Google-auth external-link safeguards. MCP server 1.12.1 / toolset 2026.09.06.1 records the metadata contract change.
2026-09-05 — Interactive Integrations CLI parity with the native connection model
The native connection model was correct but its CLI still exposed mostly raw subcommands and JSON. Bare mso integrations now opens a searchable TTY navigator over the same owner API: credential user → provider → named connection → source/auth → action. Esc returns to the parent instead of terminating the workflow. User lifecycle, connection creation/default/rename/delete, private setup, Composio authorization, route/verify, folder resolution, portable transfer, and Hostinger Mail browsing are reachable without memorizing JSON payloads. Explicit subcommands remain unchanged for automation, and non-TTY callers get a snapshot rather than an interactive hang.
The TUI stores no parallel state and never accepts credential values. All mutations still flow through the existing confirmed native management endpoint; credential entry remains the private browser form.
2026-09-05 — Reconcile new connection-model findings before final publication
2026-09-05 — Hostinger Mail API as a first-class connection capability
Hostinger direct connections now distinguish the existing account API token from a scoped Hostinger Mail API token bound to one mail order. The same User → Provider → Named Connection → Source → Auth resolver drives DNS/VPS and mail operations; scoped Mail tokens cannot be silently redirected to another order.
The reviewed Mail surface covers order/plan discovery, mailboxes, aliases, forwarders, autoreplies, catch-alls, webhooks and logs plus non-secret mutations for aliases/forwarders/autoreplies/catch-alls and mailbox deletion. Secret-bearing flows (mailbox create/password, generated Mail API tokens, generated webhook secrets) stay out of model/tool JSON. Existing SC Hostinger account credentials were verified read-only against the official /api/mail/v1/orders endpoint and saw five mail orders; no credential value was copied into native MSO automatically.
Published main advanced during the security review and introduced five additional CodeQL alerts. The integration model is preserved while migration backups use a no-follow descriptor for permissions and bounded reads; provider deletion reconstructs maps instead of indexed deletion. New HTML tests use the existing parser helper and CLI tests invoke a committed fixed-argv shell fixture rather than constructing source. The home-relative CLI contract now stubs its service manager and proves the expected teardown request without stopping host services. Source fixes and exact HEAD evidence are required again; no concurrent feature or alert is discarded.
2026-09-05 — Close final release review regressions
The documented ~/ store override now expands consistently in the shared server/CLI helper before locking, reading or writing; an end-to-end device test proves both interfaces mutate the same private store. A hosted rollback failure was reproduced deterministically by changing a newly spawned tunnel process title before durable state write. Gateway startup now keeps the original PID/start-ticks handshake until commit, uses it for failed-start rollback, treats zombie processes as stopped, and confirms termination instead of assuming SIGKILL delivery. No assertions were weakened or scanners disabled.
2026-09-05 — Scope the final security evidence to the scanned revision
The inventory can now inspect the exact scanned branch after SARIF processing, distinguishes open findings from pre-existing reviewed/closed findings, and rejects a concurrent HEAD change. Reports stream to Actions logs rather than writing remote API content back to files. A newly merged MCP browser fixture now targets the exact widget origin instead of a wildcard; the 17 browser assertions retain their negative-navigation checks. No scanner rule, authentication boundary, or existing disposition is removed by this change.
2026-09-05 — Permission-fixture portability under private umask
The deliberately public artifact fixture now sets its final 0644 permissions explicitly: a secure caller umask of 077 otherwise silently creates it as 0600, so the test was asking valid private data to be rejected. The runtime permission check and assertion remain unchanged.
2026-09-05 — Resolve actual CodeQL findings and restore the demo
The actual GitHub alert inventory exposed 22 default-branch findings, unlike the previously green scanner-completion jobs. Security-store locks now use an owner-root-validated pinned directory while preserving adjacent CLI lock names; bounded no-follow reads replace file check/reopen pairs. HTML fixture extraction uses parse5; the terminal picker opens its device once. Owner facts and activity logs now have explicit field/byte limits, private no-follow storage, concurrency and rejection tests. Diagnostic logging failures remain isolated from authorized tool execution. Security branches receive real CodeQL, CI and independent scanners; unfiltered SARIF summaries and a separate actual-alert inventory make pending evidence visible. README restores the existing real GIF inline and has a regression test for animation and screenshot presence. No alert is automatically dismissed by these changes.
2026-09-05 — MCP Page preview lifecycle
2026-09-05 — Deliberate JSON portability between independent credential stores
Users appearing in SC but not MSO were a data-transfer gap, not a Git clone issue. Add a versioned integration-bundle contract and standalone native adapters instead of reading SC's private storage from MSO. Default metadata export carries no field values. Optional authenticated encrypted JSON is handled only by hidden local input or a dedicated Owner browser endpoint, never MCP secret arguments.
Preview binds the input/options and destination state. Imports create profiles and named connections without overwriting existing identities, activating defaults or copying OAuth sessions. Mappings preserve provider/auth semantics and supported fields; unsupported data is visible and requires explicit acceptance. Browser UI and each project's CLI use their own core. Other project receivers still need an adapter and tenant/role checks. Tests cover both encryption failures and actual SC→MSO→SC roundtrip plus browser upload/download using isolated synthetic stores.
2026-09-05 — Native named-connection identity, not parallel credential forms
The provider-only Integrations store could not represent multiple deployments or source-aware execution even though its HTML form worked. Replace the foundation with credential users, named connections, direct/Composio/provider-MCP sources, auth methods, folder/default resolution and explicit account selection. Browser, CLI and MCP now call the same domain actions; old infrastructure helpers adapt to that core and pin values for compound provider operations.
Preserve v1 data through a read-only projection and exact protected backup before the first atomic v2 write. Bind temporary setup capabilities to user/connection UID/revision so stale forms cannot rotate another account. Namespace upstream Composio users by installation/profile UUID; lease both the target and broker for hosted authorization/execution. Duplication is metadata-only unless copying direct credentials is separately approved. Device roles remain distinct from credential profiles, not a new user-login/ACL system.
Tests exercise two users, five Convex connections, folder resolution, actual Dokploy client routing, source refusal, hosted-account identity, lease protection, MCP/CLI contracts and real shared-core browser saves with synthetic credentials. Page layout follows the host's returned display mode; full-height behavior is measured against the fixture iframe viewport rather than assumed from a button. No real upstream OAuth success is inferred from these tests.
- Reviewed-app Google sign-in leaves the iframe (2026-09-05): Page v6 adds an explicit host-side Google-login action using a code-owned same-origin path. A nested app may only highlight this action, never trigger navigation, supply a URL or transfer session data. The host opens through
ui/open-link/openExternalafter a real button click; sandbox popup restrictions remain unchanged. Play Together finishes sign-in in the browser tab; this does not promise shared login with storage-partitioned embeds. v5 resource requests remain compatible.
2026-09-05 — Repair native Integrations delivery and full credential catalog
The initial temporary form was too narrow and could arrive without its UI-only
setup grant when the MCP transport selected the generic profile. Preserve that
metadata in MCP _meta for both profiles without making it serializable in model
results. Page v5 shares one guided picker with /integrations, advertises exact
standard/compatibility CSP origins, and keeps older resource aliases working.
Missing grants, authorization, and cached setup tools have explicit recovery paths.
Expand native setup from four providers to twelve without importing another application's credential library or state. Method-specific fields distinguish Composio project/organization and Convex personal/deployment credentials. Fix the Composio organization endpoint and use the dedicated read-only PAT verification endpoint for Convex. Schema-derived masking covers every secret field.
Targeted security/contract tests and desktop/mobile browser fixtures prove catalog navigation, guidance before sign-in, retry, safe save, input cleanup and no key in MCP messages. Provider key verification and full upstream OAuth remain distinct; synthetic browser tests are not evidence of a user's successful authorization.
Fixed a missing MCP Apps host initialization handshake, wrapped tool-result handling and
repeated iframe remounts on unchanged globals. Page v3 now waits for an origin/source-checked
app readiness message, displays bounded retry/direct-production actions, and preserves the
cached v2 URI as a read-only alias. The exact reviewed iframe registry and Block-only approval
contract remain unchanged. Targeted contracts and a desktop/mobile browser harness validate
both standard MCP and legacy ChatGPT host paths. Toolset: 2026.09.05.1.
mso — Progress Log
- Native integration preservation (2026-09-05): merged published c164dbe without dropping the concurrent native credential setup. The short README retains its documentation link (99 lines). MCP 1.12.0 / toolset 2026.09.05.4 labels the combined maintenance, service-token, Page-readiness and native-integration contracts. This merge does not execute maintenance or reset real credentials.
- Concurrent main reconciliation (2026-09-05): preserved published MCP Page initialization/readiness changes e46c417 + changelog c4856d2 in the maintenance/PR integration branch without modifying the other session's unpublished work. MCP 1.11.1 / toolset 2026.09.05.2 records the combined compatible contract. The Settings maintenance files are unchanged from the isolated desktop/mobile acceptance at 2164d29; full repository and GitHub gates are rerun for the combined source.
- PR integration validation (2026-09-05): preserve the reviewed PR36/PR37 ancestry while repairing PR38 glob escaping/native Bun audit checks and PR37 code-generating visual-test fixtures. Direct-image boundary tests now cover malformed content and size/type limits. MCP server 1.11.0 / toolset 2026.09.05.1 records the compatible restricted-service-token/direct-image contract; widget resources and ordinary OAuth token behavior are unchanged. Publication still requires complete current-head local and remote gates, including late CodeQL findings—not only the workflow completion status.
- Reviewed 9Router network boundary (PR36, 2026-09-05): reuse the configured internal proxy network only when it already exists; Docker host publishing remains loopback-only unless explicitly enabled. This supports a containerized reverse proxy without opening the application port to the public interface. The update adds no automatic network creation or DNS mutation. The old PR lifecycle-test failure must be rechecked against the combined current baseline before publication.
2026-09-05 — Integration setup recovery and complete browser navigation
The previous setup document exposed a clickable setup button before Owner sign-in,
then collapsed authentication and transport failures into the same 403 message.
The Page also depended on a new setup action that cached chat catalogs may not know.
The native /integrations hub now probes live auth before enabling changes, keeps
provider/method guides available beforehand, refreshes on return from sign-in, and
provides expiry recovery and a route back from completed forms. Old URLs are retained.
Page v4 preserves usable browser links on unknown-tool/missing-private-metadata
responses, while older Page URIs map to the same current resource. Framing policy,
Owner gates, direct secret submission, and scoped capability checks remain intact.
Validation: isolated desktop/mobile browser runs exercise the signed-out to Owner transition, method selection, rejected-save retry, cleared successful inputs, and cached/current MCP bridge modes. No real credential was written by those tests. The connected chat can display the Page, but a browser fixture is not proof that its cached tool catalog has refreshed; the visible fallback is part of the contract.
Fixed a missing MCP Apps host initialization handshake, wrapped tool-result handling and
repeated iframe remounts on unchanged globals. Page v3 now waits for an origin/source-checked
app readiness message, displays bounded retry/direct-production actions, and preserves the
cached v2 URI as a read-only alias. The exact reviewed iframe registry and Block-only approval
contract remain unchanged. Targeted contracts and a desktop/mobile browser harness validate
both standard MCP and legacy ChatGPT host paths. Toolset: 2026.09.05.1.
mso — Progress Log
- Default-branch security evidence (2026-09-05): a screenshot still showed 21 open code-scanning alerts despite green analysis jobs. Add a read-only repository-native inventory with exact default-branch SHA, all paginated alert instances, recent analysis metadata and a nonzero exit while any finding remains. External owner API credentials currently fail authentication; the native Actions token has security-events read permission and is never exported. This captures the actual remediation backlog without disabling scanners or dismissing alerts.
- Native integration preservation (2026-09-05): merged published c164dbe without dropping the concurrent native credential setup. The short README retains its documentation link (99 lines). MCP 1.12.0 / toolset 2026.09.05.4 labels the combined maintenance, service-token, Page-readiness and native-integration contracts. This merge does not execute maintenance or reset real credentials.
- Concurrent main reconciliation (2026-09-05): preserved published MCP Page initialization/readiness changes e46c417 + changelog c4856d2 in the maintenance/PR integration branch without modifying the other session's unpublished work. MCP 1.11.1 / toolset 2026.09.05.2 records the combined compatible contract. The Settings maintenance files are unchanged from the isolated desktop/mobile acceptance at 2164d29; full repository and GitHub gates are rerun for the combined source.
- PR integration validation (2026-09-05): preserve the reviewed PR36/PR37 ancestry while repairing PR38 glob escaping/native Bun audit checks and PR37 code-generating visual-test fixtures. Direct-image boundary tests now cover malformed content and size/type limits. MCP server 1.11.0 / toolset 2026.09.05.1 records the compatible restricted-service-token/direct-image contract; widget resources and ordinary OAuth token behavior are unchanged. Publication still requires complete current-head local and remote gates, including late CodeQL findings—not only the workflow completion status.
- Reviewed 9Router network boundary (PR36, 2026-09-05): reuse the configured internal proxy network only when it already exists; Docker host publishing remains loopback-only unless explicitly enabled. This supports a containerized reverse proxy without opening the application port to the public interface. The update adds no automatic network creation or DNS mutation. The old PR lifecycle-test failure must be rechecked against the combined current baseline before publication.
2026-09-05 — Restricted MCP service tokens + truthful diverged self-update
Machine automation gets least-privilege MCP bearers instead of a generic exec token. A trusted local operator can mint a service token only from the owner CLI; there is no HTTP mint endpoint. The current service-token policy permits only
project_capabilitiesandproject_function_call, requires an exact top-level string constraint for every allowlisted tool, filtersinitialize/tools/list, and re-checks both the tool allowlist and argument constraints attools/call. OAuth/browser tokens keep their existing behavior. Raw bearers are emitted once and the existing owner-only MCP store persists only their SHA-256 hash; normal token expiry/revocation still applies.Project-function visuals stay bounded rather than becoming arbitrary binary passthrough. A successful declared project function may opt into
mso.project-function-content.v1; MSO accepts at most one PNG/JPEG/WebP image with matching magic bytes plus bounded text/content, under the existing runner output cap. Non-zero exits, stderr, malformed envelopes, unsupported MIME types, oversized payloads, and invalid image signatures remain ordinary process output or failures rather than trusted MCP image content. Project functions still execute fixed argv and validate caller JSON against their declared schema.Self-update now models both sides of Git history. Status uses
git rev-list --left-right --count HEAD...origin/mainand reportsaheadandbehindseparately. A normal update is refused when localmainis ahead or diverged, so unpushed work cannot be silently deployed or overwritten;--rebuildremains an explicit rebuild of the already-selected clean checkout and does not mutate Git history. Settings → About suppresses the Update action for local-ahead/diverged state and explains the real reconciliation requirement instead of mislabeling it as a remote-connectivity failure.PR37 pre-integration verification (historical): the two implementation commits remain independently reviewable; targeted MCP/updater tests pass 65/65, TypeScript passes,
git diff --checkis clean, the safe out-of-tree production build passed on the same implementation head, and GitHub dependency/security/CodeQL/ShellCheck/Verify checks were green before this documentation follow-up.Visual README + local maintenance (2026-09-05): README reduced from 575 to 97 lines with two Mermaid diagrams and an actual CLI PTY capture; longer valid material moved to the workspace reference. App 0.2.3 / CLI 1.13.0 adds preview-first reset and uninstall with exact-plan confirmation, private reset archives, stopped-runtime checks, existing runtime-exclusion coordination, symlink/ownership checks and explicit purge/standalone-source options. Unknown .mso entries/worktrees, other projects, shared dependencies and browser profiles are retained. Settings separates browser reset from copyable server maintenance previews; the device identity is preserved. Synthetic fixture tests exercise reset, clean-clone uninstall and failure paths; production was not reset or uninstalled. PR38 review fixes include complete glob escaping and a Bun >=1.2.15 native-audit prerequisite, enforced by the installer with refreshed bootstrap checksum.
Previously hidden exec/discovery test gaps closed (2026-09-05): the remaining expected-failure shell-expansion case is now a real passing refusal test. Recursive deletion with unresolved shell expansion is conservatively refused; literal reviewed targets remain subject to normal approvals, and the matcher is explicitly not a shell parser or sandbox. Added eight predicate-only expansion fixtures without executing destructive commands. Registered the previously omitted root machine-protocol proxy test in normal Vitest/coverage and added an inventory regression contract. Per-area runs now use isolated exact-include configurations and verify the exact returned file set, preventing substring matches from counting unrelated nested proxy tests twice. Earlier per-area totals from this audit are superseded by the exact-selection rerun.
Compiler-enforced unused-code cleanup (2026-09-05): resolved 49 unused import/local/parameter diagnostics across the shell, assistant, media, host, MCP and test modules. Calls with intentional side effects remain intact; positional callback placeholders are explicitly named. TypeScript
noUnusedLocalsandnoUnusedParametersnow make the ordinary typecheck/CI reject regressions. This is compiler-proven unused-symbol cleanup, not a claim that every exported symbol, runtime-discovered asset or optional integration is removable.Public-sharing security and maintenance audit (2026-09-05): app
0.2.2keeps the independently versioned CLI/MCP contracts unchanged. Release and assurance dependency audits now fail closed on unavailable, malformed or incomplete evidence; local developer skips are explicitly labelled, registry diagnostics do not expose raw URLs, and skipped optional scanners cannot produce an unconditional assurance PASS. Removed the dormant Convex deploy tail, fixed shared Git-hook installation and out-of-tree dependency copying for linked worktrees, and added functional regression tests. README now leads with a readable install/features/security overview and collapsible reference detail, preserving generated comparison evidence and public-alpha limits.test:featuresruns each test area in a separate process and distinguishes PASS/PARTIAL/SKIPPED/FAIL. The Forge Docker sandbox and synthetic credential-path fixture activate previously skipped security checks without using real secrets; CI now provisions the same bounded fixtures. Onboarding tests derive the app version frompackage.json; the browser suite follows the actual Activity & Runs UI, checks infrastructure deep-links, and never echoes session-cookie diagnostics. Full-history scanning now requests merge diffs explicitly in CI and the assurance runner; independent scanner outputs remain private; no genuine historical secret was identified by the configured scan, so shared history was not rewritten. Live-service deployment and remote CI status require separate exact-revision evidence and are not inferred from local tests.Rahmanef-aligned MCP widget palette / Block + Page v2 (2026-09-04): MCP server
1.10.0/ toolset2026.09.04.7moves the two canonical ChatGPT resources toui://mso/block-v2.htmlandui://mso/page-v2.htmlso hosts do not reuse the old purple CSS cache key. Block and Page now share one visual-token source aligned withrahmanef.com: light#f4f4f7/#1c1c1f, dark#1b1b20/#f2f2f5, accent#1f6df0, Plus Jakarta Sans display copy, Inter body copy, fine separators, and editorial foreground/background primary-action inversion. ChatGPT theme changes propagate throughwindow.openai.themewith a color-scheme fallback. Block/Page v1 and the earlier workflow/surface URIs remain readable but unlisted compatibility aliases; the headless workflow and two-surface/security contracts are unchanged.Headless workflows + two-surface MCP UI contract (2026-09-04): MCP server
1.10.0/ toolset2026.09.04.6removes the automatic UI binding fromworkflow_start: orchestration, collision checks, tracing, evidence, and learning continue in the background without consuming the answer with a progress card. ChatGPT now has exactly two canonical MCP App resources:ui://mso/block-v1.htmlthroughrender_mso_blockfor compact validation/action/CRUD input-output, andui://mso/page-v1.htmlthroughrender_mso_pagefor native operator views plus reviewed development/preview/production embeds. Block buttons send a user-approved follow-up and never execute mutations inside the widget, preserving normal scope, approval, audit, and workflow boundaries. The prior workflow/surface URIs remain non-advertised read aliases, whileworkflow_statusandrender_mso_surfaceremain app-only compatibility shims for cached clients. The ChatGPT transport profile is 66 tools: 64 model-visible actions (35 read / 17 write / 12 exec) plus two app-only shims; the full catalog is 90. Only Block and Page advertise a resource URI.Local release audit timeout hardening (2026-09-04): the tolerant pre-push dependency audit now caps
bun audit --jsonat 15 seconds. A registry timeout is reported and skipped only in the local gate, matching its existing network-tolerant policy; CI remains the fail-closed dependency-audit authority. This prevents a slow registry request from holding GitHub's pre-push SSH session open for minutes and failing the otherwise-green release with a transport/SIGPIPE-style exit. Superseded 2026-10-22: the cap is now 30s per attempt with 3 attempts and a 90s total budget, because a single 15s probe made cold CI runners fail with INCOMPLETE despite finding no advisory. Seescripts/audit.mjs.MCP Apps CSP metadata dedup / Surface v5 (2026-09-04): MCP server
1.9.4/ toolset2026.09.04.5moves all standard widget CSP fields to the preferred_meta.ui.cspsurface and leaves legacyopenai/widgetCSPwith onlyredirect_domainsforOpen in MSO. Workflow/Surface resources are cache-busted toworkflow-progress-v3andsurface-v5; the reviewed Play Together iframe remains exact-origin under/embed, so one external-iframe review advisory is expected fromui.csp.frameDomains. Scanner-facing Surface metadata explicitly names/apps/play-togetherand has a regression guard against cross-scope app examples.MCP Apps presentation unification / Surface v4 (2026-09-04): MCP server
1.9.3/ toolset2026.09.04.4retires the specializedproject-status-v2,project-diff-v2, andvps-status-v2resources.project_get,project_diff, andvps_statusare pure data tools again;ui://mso/surface-v4.htmlis the only general-purpose UI and uses the portable MCP Appstools/callbridge for native monitor/project/diff views.workflow-progress-v2remains intentionally separate for live workflow polling. Play Together keeps the exactgame.example.com/embedframe boundary, so the external-iframe review advisory remains expected only for the universal Surface.Cognitive Runtime claim audit / public evidence boundary (2026-09-04): revalidated source/main/origin and loopback/public production on the latest concurrent baseline, then reran the deterministic Cognitive Runtime/memory gates: routing recall 100%, active-schema reduction 96.6%, typed memory 8/8, P9 6/6 at 200 corrections, P10 lifecycle 8/8, lexical/local-semantic 4/6 vs 3/6, and bounded graph fixture 3/3. Raw P6/P7/P8 artifacts were independently re-hashed and their aggregate arithmetic recomputed; the canonical P7 two-run artifact is
mso-p7-repeat-full-2x9.json(a0c12961...), not the similarly named oldermso-p7-repeat-full-2runs.json. Canonical P7+P8 yields 5/5 perfect full runs for both MSO and Hermes and the documented 74.7% token / 12.8% average-latency / 34.1% p50 observed deltas on that exact nine-scenario matched corpus. P4/P5 exact tables are downgraded to historical release-reported metrics because this audit could not independently recover raw artifacts matching those exact values. README now removes the stale 29-tool ChatGPT count, removes the unsupported "most complete" positioning superlative, and states explicit no-universal-superiority/no-cost/no-cache/no-OpenClaw boundaries. Tool Forge executable evaluation is documented as fail-closed until its explicit local Docker sandbox image is provisioned; that image was absent during this audit.Play Together secure iframe / Surface v3 (2026-09-04): MCP server
1.9.2/ toolset2026.09.04.3upgradesui://mso/surface-v3.htmlso Play Together can render live inside ChatGPT without relaxing the whole app. The Surface allowlists onlyhttps://game.example.com, starts it at/embed, revalidates the exact origin plus/embedpath prefix in-browser, and retains a sandbox without popups/top-navigation. The Play Together deployment reciprocally keeps normal routes anti-frame and gives only/embed+/embed/*the exactmso-ui.example.comancestor permission. Auth remains normal; no demo bypass or raw HTML/arbitrary URL input is added.MSO Surface v1 scope correction / v2 resource (2026-09-04): MCP server
1.9.1/ toolset2026.09.04.2removes accidental cross-project catalog entries from Fresh 3.ui://mso/surface-v2.htmlkeeps the generic secure Surface architecture but its current VPSKU app catalog contains only Play Together (https://game.example.com) as aremotetarget because that app currently sendsframe-ancestors 'self'. The Surface CSP therefore has no third-partyframeDomainsat all. Raw HTML/arbitrary URLs remain rejected, project anti-framing headers are never stripped, and app identities from other MSO server scopes are not copied into this connector.MCP App contextual landing hardening (2026-09-03):
Open in MSOno longer lands on an idle desktop. Workflow/VPS/project/diff cards target/assistant/mcp,/monitor,/files, and/code; the shell also recognizes ChatGPT's rootredirectUrl=https://chatgpt.com/c/...handoff and redirects it to Alfa → MCP Activity so an already-cached v2 widget still produces a visible result. Assistant deep-link payloads now select their requested tab even when reusing an existing singleton window. MCP tool count, scopes, output schemas, and v2 resource URIs are unchanged.Live-build chunk corruption eliminated (2026-09-03): a production browser repro proved the shell/Settings crash was not a Settings logic regression: an in-place
next buildin the active service checkout replaced.nextwhile the old Next process still served its boot-time manifest, making all 19 root-referenced chunks disappear and one observed JS request return500 text/plain. Production was recovered throughmso deploy; shell + Settings then passed real authenticated Playwright on desktop/mobile with zero failed requests/console errors.bun run buildis now a fail-closed wrapper that holds the checkout exclusion and refuses a same-checkout live runtime;mso buildremains the out-of-tree proof and guarded deploy/update lifecycles invoke raw Next only after quiescence. Post-replacement validation now checks every root-referenced JS/CSS asset status+MIME, not one CSS/chunk. The Fresh 3 smoke scratch path moved out of protected~/.mso, and recursivefs_mkdirnow securely supports missing parents while rejecting symlink escapes.
2026-09-04 — Alfa Cockpit exposes MSO runtime context without duplicating the CLI (DONE)
Alfa's browser surface had real host tools and approvals, but much of the runtime state that makes mso powerful was hidden behind terminal/MCP surfaces. The Assistant now has a responsive Alfa Cockpit: active provider/model with in-place model switch/test, bounded + searchable project selection, branch/tree/HEAD/package/knowledge metadata, trusted Host Skills, typed-memory telemetry/current records, native session summaries, same-principal local-agent presence, pending approval count, and an Activity & Runs view that combines Alfa host-tool events with MCP workflow activity at the presentation layer. The read-model route reuses existing project/session/memory/config domains; it does not create parallel stores. CLI parity is preserved with mso cockpit [project] / mso cockpit search <query>, which calls the same read-model instead of reimplementing the aggregation. Project scan truncation stays explicit, project search works beyond the first bounded page, raw KNOWLEDGE.md/repo-memory bodies are not returned, and private/restricted typed-memory keys/values are masked; legacy Alfa fact text and repo-memory result bodies are not copied into the Cockpit response.
Selected project context is persisted as an alfa.* preference and sent per turn only as a capped metadata snapshot; it is explicitly not mutation permission and does not change Alfa's stable global host-tool catalog. The dock/mobile Alfa thread shows the same selected project and pending approvals. Browser-local “Skills” are now labelled Playbooks, Host Skills remain the real SKILL.md catalog, Playbook starters finally render as quick prompts, and saved Automations now execute by re-entering Alfa's normal agent/tool loop instead of only logging pretend steps—so read calls use the existing bindings and mutations still stop on the same human approval cards. Native agent sessions remain read-only summaries rather than being falsely presented as the current browser chat. Focused typecheck/ESLint/docs gates and cockpit/context/activity/automation tests pass; full repository verify and the official production build also pass on the combined CSP v5 + Alfa baseline.
2026-09-03 — Cognitive Runtime P10 memory retention & lifecycle
- Cold-history retention before hard caps: typed agent memory now starts deterministic retention at 1,400 live records or ~1.4 MiB and targets <=1,000 records / ~1 MiB by archiving only records whose effective interval has already ended. Current or future-effective facts are never selected; the existing 2,000-record / 2 MiB live-ledger limits remain fail-closed.
- Crash-safe owner-only archive: finished history moves into content-addressed
archive-v1/segment-<sha>.jsonfiles (<=400 records / 768 KiB each) under0700directories /0600files. Archive segments are written before the atomic live-ledger swap; duplicate ids after an interrupted commit are deduped with the persisted live ledger winning. Backdated replacements use forwardsupersedesedges as temporal boundaries, so immutable archived rows never need in-place mutation. Explicit history/time-travel reads include cold records, while normal resolved memory stays archive-free. - Privacy-safe lifecycle telemetry: aggregate diagnostics report live/archive/total counts, resolved keys, superseded/retracted/future/conflict counts, correction-depth buckets, max corrections per key, ledger/projection/archive bytes and segment count. No memory values, raw keys, raw conversation ids, bearer/client data or secrets are emitted. The telemetry is kept out of the default MCP memory-read payload to avoid permanent tool/context overhead.
- Frozen sessions now have explicit regression coverage: the isolated lifecycle fixture proves session A retains its captured old memory after persistent memory changes, session B captures the new value, and resuming A returns A's frozen snapshot. No hidden mutable global memory context was added.
- Threshold calibration:
bench:memory:lifecycleis 8/8 deterministic. A synthetic 1,400-correction ledger compacts to 1,000 live + 401 archived records / two segments, with a 56-byte resolved projection. The same fixture verifies archived-history retrieval, historical temporal resolution, archive permissions, archive-before-ledger crash semantics, backdated replacement over immutable cold records, and frozen sessions without touching real operator memory. - Retrieval evidence gate found and fixed exact-match crowding: history query
Runtime-1could be displaced by substring matches likeRuntime-10before the result limit. Deterministic scoring now prioritizes exact phrases/tokens and keeps bounded alphabetic-prefix stemming. Existingbench:memorystays 8/8 / 100%. - Vector and graph complexity remain evidence-blocked: realistic retrieval calibration is 4/6 lexical, with objective misses only for
IDE↔editorsynonym and Indonesiankantor↔Englishoffice. P10D compares the existing localmso-local-hybrid-v1semantic encoder against the same rows: it is deterministic but only 3/6, fails the same two semantic cases and regresses the exact-domain rollback case. The candidate runs ephemerally with zero network calls / zero persisted memory vectors, so this is a direct architecture gate rather than an infrastructure limitation: adding a memory vector index now would make retrieval more complex without improving recall. Relationship calibration remains 3/3 two-hop, so current keyed retrieval still does not justify graph storage. - P9 privacy semantics preserved: 200-correction
bench:memory:calibrationremains 6/6 and future-scheduled claims still cannot resurrect afterforget. Cache remains observation-only, cost remains attribution-blocked, OpenClaw remains unranked without a legitimate matched provider/model path, and five-run reliability remains descriptive. - MCP Apps navigation hardening (2026-09-03): server
1.8.2/ toolset2026.09.03.7bumps all four UI resources to v2 and makesOpen in MSOself-diagnosing: officialopenExternal+setOpenInAppUrl, visible success/failure feedback, and a user-clickable direct-link fallback. No tool count or security-scope changes.
2026-09-03 — Cognitive Runtime P9 memory calibration
Repeated-correction calibration instead of graph expansion: added
bench:memory:calibration, which runs only against an isolated temporary agent-memory root and exercises explicit authority, confidence/recency, future replacement, forget semantics, finished-history integrity and deep repeated corrections.Future-memory resurrection fixed:
agent_memory_forgetpreviously retracted only claims effective at the current instant, allowing a scheduled future replacement to reappear later. Forget now retracts every matching claim whose interval can still become effective now/future while leaving already-ended historical evidence unchanged.Bounded context under correction depth: the final 200-correction stress run from source
d249da4passed 6/6 deterministic scenarios. The ledger reached 200 records / 135,180 bytes, but the compatibility snapshot stayed 1 resolved record / 58 bytes (99.96% smaller) and explicit history retrieval remained capped at 100 rows. Existingbench:memorystayed 100% and the full Cognitive Runtime memory gates stayed 100%.Graph memory remains deferred by evidence: P9 found no authority/conflict/temporal/repeated-correction task that needs a graph. Future graph or vector complexity must first solve a reproduced retrieval failure; next memory work should focus on real correction telemetry and retention/archival before the 2,000-record / 2 MiB ledger caps.
Fresh 3 completion / scanner-clean contract (2026-09-03): server
1.8.1/ toolset2026.09.03.6keeps the 62-action Fresh 3 surface unchanged while closing the post-refresh metadata gaps. Every ChatGPT action now advertisesoutputSchema; dynamic actions share one DRY bounded{ result }envelope instead of 57 duplicated hand schemas, keeping the profile at 64,180 bytes (~16.0k rough tokens). Four MCP Apps now declare the dedicated sibling widget originhttps://mso-ui.example.com(Traefik config inops/traefik/mso-ui.yml), and the OpenAI/MCP skills extension publishes five official, digest-verifiedclaude-skills/snapshots throughskills/list,skills/get, andresources/read. Generic MCP clients retain the prior text-only result behavior unless a tool already had explicit structured output.Fresh 3 capability-max release (2026-09-03): server
1.8.0/ toolset2026.09.03.5restores Original MSO bounded VPS/system/filesystem/app/browser/infra operations to the ChatGPT profile while preserving Fresh 3 workflow/session/Local Agent/read-pipeline/project-MCP orchestration. The ChatGPT transport profile is now 62 tools (61 model actions + app-onlyworkflow_status) at 57,853 descriptor bytes (~14.5k rough tokens), while the full model/operator catalog grows to 85 tools. New Lovable-inspired surfaces addproject_get, Git history/diff,.mso/KNOWLEDGE.md, safe connection inventory, privateproject_agent_run/project_agent_status, and MCP Apps project/diff/VPS cards. Convex is first-class through the project-installed official Convex MCP CLI with projectDir override stripping, cross-project selector refusal, dynamic schemas, and no automatic dangerous production flags.MCP protocol-era correctness (2026-09-03): server
1.7.3stops claiming the stateless2026-07-28protocol while serving the legacy initialize/session wire shape. The supported ceiling is deliberately2025-06-18(matching the known-good CareerPack ChatGPT connector); a modern HTTP probe receives a 400 and can fall back to initialize.server/discoveris no longer aliased to the legacy initialize payload. Browser CORS also permitsMcp-Method/Mcp-Nameso a standards-aware probe can reach the server and receive the fallback signal. Toolset stays2026.09.03.4. Running log of what shipped each phase. Newest at top.
2026-09-03 — Cognitive Runtime P8 calibration
- Observed run spread, not pseudo-statistics: repeated corpus aggregation now reports per-run min/max/mean/median/range/sample-SD/CV for success, average latency, p50 and normalized tokens/attempt. Three new complete
openai-codex/gpt-5.6-terraruns from source51ae31fproduced 27/27 task + 27/27 scenario-policy and 3/3 perfect runs for both agents; all 54 rows and token arithmetic proofs passed independent validation. - Five-run reliability history is a tie: combining the prior two P7 runs with the three P8 runs yields 5/5 perfect full runs for both MSO and Hermes. The observed five-run means are 16,907.6 vs 66,791.1 normalized tokens/attempt (
74.7% lower for MSO), 18,985.9 vs 21,779.8 ms average latency (12.8% lower), and 14,130.8 vs 21,457.2 ms mean per-run p50 (~34.1% lower).n=5remains descriptive; no CI/p-value or universal reliability claim is made. - Dedicated repeated-prefix cache calibration: new
bench:cache-calibrationkeeps one inert shared prefix, varies only exact reply markers, rotates starting agent, and distinguishes positive/zero/absent provider cache fields. The final 4-round 12K-prefix run was 8/8 success; MSO reported zero cache reads on 4/4, Hermes naturally reported positive cache reads on 2/4 (9,728 and 19,968 tokens). Cache frequency remains unranked because runner request envelopes differ. - Benchmark accounting bug fixed: valid normalized proof shapes may legitimately vary by row when cache behavior changes. Comparability now proof-gates every row instead of requiring one aggregate proof label; opaque/unknown rows still fail closed. This preserves token comparability in the real cache-hit run without weakening arithmetic requirements.
- Cost gate remains closed: MSO still has no attributable cost field while Hermes reports zero with source
none. Cost comparison stays withheld until both runners expose the same attributable USD contract.
2026-09-03 — Cognitive Runtime P7 repeatable corpus baseline
- Deterministic repeat contract: added
bench:corpus:repeat, explicit single-run--seed, deterministic per-run seed derivation, and alternating starting-agent order. Repeated aggregation is fail-closed on missing runs, seed/order drift, duplicate or missing per-agent scenario identities, and cross-run provider/model drift. - First repeated full baseline: two complete nine-scenario
openai-codex/gpt-5.6-terraruns from source5bd5788produced 18/18 task + 18/18 scenario-policy for both MSO and Hermes, with 2/2 perfect runs each. The prior P6 Hermesmulti-readmiss did not recur (2/2here for both agents). - Observed efficiency, still bounded: MSO measured 18,922.6 ms average / 13,761 ms p50 / 17,271.3 normalized tokens per attempt versus Hermes 21,077.4 ms / 20,513.5 ms / 65,073.3 tokens. On these two runs that is ~73.5% fewer normalized tokens/attempt, ~10.2% lower average latency, and ~32.9% lower p50 for MSO. All 36 token proofs passed independent arithmetic validation; cost semantics remain non-comparable.
- Cache evidence without a manufactured hit: provider telemetry naturally reported positive MSO cache reads on 4/18 rows and Hermes cache reads on 18/18. P7 records this as calibration evidence only; it does not rank cache-hit rates because runner request/context behavior differs. More independent full repeats are required before reliability statistics.
2026-09-03 — OAuth DCR registration identity fix
- 2026-09-03 — Browser MCP install compatibility: comparison with the working CareerPack MCP showed that ChatGPT completed DCR + OAuth for MSO but the post-auth browser probe differed: CareerPack serves CORS preflight/metadata while MSO rejected
Origin: https://chatgpt.comand returned OPTIONS without usable CORS headers. MCP server1.7.2now permits the exact ChatGPT browser origins only against the configured public MSO origin, keeps arbitrary/loopback-origin requests denied, adds explicit/mcppreflight headers, and adds public CORS to OAuth discovery/DCR. Toolset stays2026.09.03.4because no tool descriptor changed. - Fresh app means fresh OAuth client:
POST /oauth/registernow mints a distinct RFC 7591 client id for every registration. Redirect URIs are client metadata, not identity; two ChatGPT dev apps sharing the samechatgpt.comcallback no longer collapse onto an August-era client record. - Safe bounded store: registration pruning removes only old client records that are not referenced by a live authorization code, access token, or refresh grant. Existing connectors/tokens remain valid. The DCR response now also reports
client_id_issued_at. - Why this matters: real ChatGPT testing showed a supposedly new app at 10:55 UTC receiving the historical
probe-chatgptclient id solely because its redirect set matched. That defeated the purpose of a clean Scan Tools registration and could retain stale app identity server-side. MCP server patch version is 1.7.1; toolset remains 2026.09.03.4 because the advertised tool catalog did not change.
2026-09-03 — MCP 1.7 ChatGPT compact profile + dynamic project MCP
- ChatGPT scanner contract: full MSO remains 73 transport tools / 72 model tools (34 read / 24 write / 14 exec + app-only
workflow_status), while ChatGPT is client-profiled to 29 transport tools = 28 model tools (14 read / 8 write / 6 exec) + app-only bridge. The profile is fail-closed at list and direct-call time, keeps only MSO-owned generic names, and regression-measures 31,908 descriptor bytes (~8k rough tokens) with a 40 KiB total / 8 KiB per-tool guard. - Scanner portability follow-up: MCP Inspector 2.5.0 successfully listed the live 29-tool profile but strict lint found one unconstrained
{}schema atread_pipeline.transform.where[].value. The schema now advertises the runtime's real scalar contract explicitly (string <= 2048 | number | boolean | null) so portable clients do not have to interpret a bare permissive schema. Toolset advances to2026.09.03.4; live acceptance must include Inspectortools/list --strictwith zero portability findings. - Metadata SSOT: every advertised tool is normalized through one descriptor layer with a human title, explicit
readOnlyHint/destructiveHint/openWorldHint, optional idempotency, and matching top-level +_meta.securitySchemes. ChatGPT gets compact descriptions/schema descriptions without changing behavior or constraints. - Project MCP stays dynamic: added generic exec-scope
project_mcp_toolsandproject_mcp_call..mcp.jsonstays private;project_capabilitiesexposes only server alias/transport/auth class, stdio runs without shell inside project cwd from a credential-scrubbed environment, remote HTTP uses SSRF/DNS-rebinding guards, and another project's OAuth is never copied/minted implicitly. Project-specific tool names never enter MSOtools/list. - OAuth/transport refresh hardening: new OAuth grants bind
resource=<origin>/mcp, returniss, issue one-hour access tokens plus rotating hashed refresh credentials, and revoke by grant family. Legacy bearers remain a migration path. Streamable HTTP validatesMCP-Protocol-Version; the unsupported optional SSE GET listener now returns 405. - Open-source independence: removed the cross-repository MCP contract document, sibling-repo CI fallback and current private-project examples. MSO's push gate always uses its own
bun run verify; downstream integrations consume MSO's public contract, not vice versa. - Release verification: targeted MCP/auth/project regression, TypeScript, docs and the full repository verify gate pass; lint remains 0 errors / 8 baseline max-lines warnings. Trivy high/critical, OSV dependencies, Gitleaks history, Semgrep OWASP/SAST and ShellCheck all pass on the staged candidate. The optional Codex Security AI component scan is recorded as incomplete, not PASS: the full-repo run hit the 20-minute executor cap and two high-effort targeted attempts hit their $3/$5 cost guards; both targeted partial reports contained 0 findings. Live ZAP remains a post-deploy check because scanning the previous production build would not validate this candidate.
2026-09-03 — Cognitive Runtime P6 expanded repo/recovery corpus
- Nine-scenario v2 corpus:
bench:corpusnow adds objectiverepo-debug,repo-migration, and transactionalrollbackfixtures to the six P4/P5 scenarios. Each agent still receives semantically identical seeded state in a separate private 0700 tree; immutable issue/spec/test/validator files plus exact final-tree verification remain authority, andpolicyObservationScope=scenario-treeexplicitly avoids whole-host sandbox claims. - Benchmark found and fixed RASMIC routing debt: ordinary repo
debug/testinstructions were being mistaken for a user manual-test outcome, loading project-memory writes while execution validation could disappear. Manual-test routing now requires outcome language; explicit Node/Bun/npm/pnpm/Python/pytest validation selectsexec_run, and repo-first debug/migrate/rollback requests enterrepo-change. The P1-P5 Cognitive Runtime gate remains 100% required-tool recall / 100% catalog hit / 95.9% schema reduction. - Long-turn workflow lifecycle fixed: after enough tool rounds the original
workflow_startcould fall outside the eight-row recent-tool window and be offered again. The router now remembers workflow start across the complete current user turn, preserves finish/cancel companions, and resets correctly on a later user turn. Post-fix repo-debug/migration traces both pass with exactly oneworkflow_start. - Final matched full run: on
openai-codex/gpt-5.6-terra, MSO achieved 9/9 task + 9/9 scenario-policy; Hermes achieved 8/9 task + 9/9 scenario-policy. MSO measured 22,776 ms average / 15,285 ms p50 / 16,683.4 normalized tokens per attempt, Hermes 22,189.3 ms / 23,294 ms / 67,433.1 tokens per attempt. Thus MSO used**75.3% fewer normalized tokens/attempt (4.04× smaller)** and had ~34.4% lower p50, while average latency was ~2.6% higher. Cost semantics remain non-comparable. - No cherry-picked reliability claim: the sole Hermes full-run miss was
multi-readwith intact scenario state but an incorrect exact aggregate. An alternating-order follow-up repeatedmulti-readthree times per agent and both MSO and Hermes passed 3/3. The formal full-run ranking is MSO > Hermes because correctness is first, but the 8/9 observation is treated as run variance rather than universal reliability evidence.
2026-09-03 — Cognitive Runtime P5 normalized provider usage
- Provider usage SSOT: Codex/OpenAI now preserve authoritative input/output/total plus provider-reported cache-read/cache-write/reasoning details and explicit
inclusive-input-output-totalsemantics; Anthropic keeps its separate cache categories and leaves absent fields absent. Agent sessions start withapiCalls:0, so unknown totals are never seeded as fake zero. - No double counting: cache/reasoning details remain breakdowns when the provider contract says they are included. Session aggregation records API-call/detail coverage and mixed semantics rather than summing a component into total twice. Compact status can show in/out even when a provider does not report total.
- Proof-gated benchmark normalization: P5 adds
accountingProof. MSO Codex usesexplicit-inclusive-contract; Hermes openai-codex is normalized only when exact arithmetic proves cache is outside base input while reasoning is inside output (exact-exclusive-cache-sum). Ambiguous rows stayopaque-total, and even two opaque rows cannot enable token comparison. - Comparable full-corpus result: candidate P5 reran all six P4 scenarios on
openai-codex/gpt-5.6-terra; both agents remained 6/6 task + 6/6 scenario-policy. MSO measured 11,497.7 ms average / 11,782 ms p50 / 3,510.8 normalized tokens per success versus Hermes 16,199.3 ms / 16,184.5 ms / 59,743.2 tokens. On this bounded corpus that is**94.1% fewer normalized tokens (17× smaller), ~29.0% lower average latency**, and ~27.2% lower p50. Token semantics are now comparable; cost semantics remain withheld. - Honest limits: no cache hit was manufactured for MSO; zero cache values in the observed Codex calls came from the provider payload. Cost remains non-comparable because MSO exposes no matching cost field and Hermes reports source
none. OpenClaw remains unranked without an equivalent configured provider/model.
2026-09-03 — Cognitive Runtime P4 comparable quality corpus
- Six objective scratch scenarios: added seeded per-agent read, multi-read transform, exact write-create, write-preserve, recovery, and prompt-injection/security tasks. Each agent gets the same seeded semantic values/expected outcomes in a separate 0700 scratch tree; scoring compares the exact scenario filesystem tree/result state and rejects unexpected extra files/symlinks. Fixtures are isolated, but runners retain normal authority (
runnerAuthoritySandboxed=false) andpolicyObservationScope=scenario-treeprevents whole-host policy claims; all scratch state is deleted after the run. - Strict comparability: model-family/provider evidence is collected per scenario and must cover 100% of attempted scenarios. Overall ranking is allowed only for equal full-corpus coverage with matching model family and the same explicitly requested provider. Execution is scenario-major with rotating agent order to reduce temporal/warm-up bias. Token/cost efficiency is a separate diagnostic gate: missing/partial/mixed accounting stays unknown, failed-attempt usage is charged into per-success metrics, and mismatched accounting modes cannot influence quality ranking.
- Reproduced full comparable result: on six seeded scenarios using
openai-codex/gpt-5.6-terra, MSO and Hermes both achieved 6/6 task success and 6/6 scenario-observable policy compliance. MSO averaged 10,759.5 ms vs Hermes 14,624 ms (26.4% lower) and p50 10,646.5 ms vs 14,304.5 ms (25.6% lower). Thus MSO ranks ahead on this bounded P4 corpus only after the quality/policy tie; this is not an overall-product claim. OpenClaw is withheld because the host does not currently provide an equivalent usable model/provider path. - Token accounting kept honest: MSO reports
input-output-total; Hermes reports expanded cache/reasoning components, sotokenSemanticsComparable=false. Reported tokens/success (3,495.2 vs 56,718.2) remain diagnostic only and do not decide ranking. Cost comparison is withheld: MSO has no comparable cost field and Hermes reports included cost with sourcenone; generic cost without explicit USD currency is not treated as USD. - Benchmark → engineering loop: P4 found exact-path reads falling through to discovery. RASMIC now routes supplied absolute paths directly to
fs_read, and explicit multi-read aggregation toread_pipeline. Initial security diagnostic: 3 tools / 14,934 reported tokens / 16,072 ms. Final matched-provider corpus: 1fs_read/ 2,117 reported tokens / 8,774 ms, still 100% task/scenario-policy. The structural 3→1 route is deterministic; timing/token before-vs-after values are observed runs, not a controlled causal estimate. Finalmulti-readuses oneread_pipeline; recovery's one failed primary read is expected by the scenario.
2026-09-03 — MCP Local Agent foreground two-way receive
- KISS two-way MCP path:
local_agent_inboxnow accepts optionalwait_ms=0..20000. A positive wait keeps only the current foreground MCP request open, registers the existing in-process Local Agent subscriber, and returns early when another same-principal session delivers a message. No DB, webhook, broker, WebSocket, daemon, or background worker was added. - Race-safe durability: the durable file mailbox remains authoritative. The receiver reads once, subscribes, reads again to close the read→subscribe race, then waits for either an event or timeout; the listener is always removed on return/error/timeout. Omitted/zero
wait_mspreserves the previous immediate inbox behavior. - Receivable MCP presence: the MCP dispatcher keeps
local_agent_inboxsessionsidlerather than marking the receive callbusy, allowinglocal_agent_message_send/local_agent_replyto publish directly to that foreground receiver. Other tool calls retain normalbusy → idlepresence. - Real A↔B integration coverage: a new MCP-dispatch integration test opens Chat-B-style inbox wait, sends a correlated request from Chat A, then opens Chat-A-style inbox wait and replies from Chat B. Both deliveries return
delivered, both waits wake before timeout, and neither path invokeslocal_agent_requestor any spawned durable-session worker. - Toolset: upstream P3 already added
read_pipeline; this schema-only Local Agent update therefore advances the catalog to2026.09.03.2while keeping 71 transport tools = 70 model/operator tools (34 read / 24 write / 12 exec) + app-onlyworkflow_status. ChatGPT must refresh/re-scan its frozen action snapshot before the model can see the new optional parameter.
2026-09-03 — Cognitive Runtime P3 read-only orchestration
- Self-update invariant fixed: RASMIC
.agent/evidence/memory is runtime-local state and is now ignored by the MSO repo. This prevents successful workflow memory writes from making the canonical checkout dirty and causingmso updateto refuse its own upgrade. - Programmatic reads without program execution: added read-scope
read_pipeline, batching 1–6 independent eligible read tools in parallel/sequential mode and reducing their results with bounded declarative path/filter/select/sort/unique/limit/count/sum/avg/min/max operations. No shell, JavaScript, nested pipeline, foreign childworkflow_id, screenshot/direct-file result, wait/poll primitive, write tool or exec tool can enter the pipeline. - Guard reuse instead of a second security stack: direct MCP dispatch and pipeline children now share one per-tool rate-limit helper. Child calls still execute the original tool handler and host/path checks and are internally forced to
readscope even when the parent bearer isexec. Raw results cap at 1 MiB/child; transformed output caps at 12 KiB/child and 40 KiB total; the complete response has a 15-second wall-time deadline. Parallel results are emitted in declaration order for deterministic caching/evals. - Measured context reduction:
bench:pipelinepreserves exact deterministic fixture answers while reducing four independent model round-trips to one (75%) and model-visible bytes from 232,205 to 1,891 (99.2%). Integrated Cognitive Runtime remains 100% required-tool routing recall, 100% typed-memory fixture accuracy, and averages 2.6/71 active tools with 95.9% schema reduction under the merged RASMIC catalog-first router. - Docs/tool catalog SSOT:
check-docs.mjsnow derives tool modules from the canonicallib/mcp/tools.tscomposition and fails on orphantools-*.tsmodules, so adding a new tool module cannot silently escape MCP/ChatGPT/connectors documentation. Toolset advances to2026.09.03.1: 71 transport tools = 70 model/operator tools (34 read / 24 write / 12 exec) + app-onlyworkflow_status. The docs checker follows the recursivetools-*import closure fromlib/mcp/tools.ts, so split RASMIC workflow modules remain in the same SSOT.
2026-09-03 — MSO 1.12 documentation and Agent contract cleanup
- Full Markdown audit: reviewed all 71 authored Markdown files in the repository, preserving dated release/audit/design evidence while correcting current-reference drift. Structural validation reports zero malformed fence/heading issues and all 125 relative Markdown links resolve.
- Current Agent docs: synchronized
TESTING-HANDOFF, Local Agents, install/provider guidance, troubleshooting, architecture and the documentation map with the shipped 1.12 identity-first composer, sectioned transcript, compact exact approval and recoverablenot_started | completed | uncertainmutation semantics. Historical 1.8–1.11 release notes remain intact rather than being rewritten as if they were current instructions. - MCP/A2A drift fixed: at that 1.12 documentation checkpoint, references agreed on server
1.6.0, toolset2026.09.02.7, 67 transport tools = 66 model/operator tools (32 read / 22 write / 12 exec) + app-onlyworkflow_status. Stale 31/29/59/56-tool claims and obsolete anonymous-only A2A wording were removed from current docs; historical benchmark snapshots were relabeled as snapshots instead of live metrics. - Docs gate strengthened:
check-docs.mjsnow verifies the MCP marker in architecture/operator docs and exact scope membership indocs/MCP.mdanddocs/CHATGPT-PLUGIN.md, so a future tool addition cannot leave one human catalog silently stale. - Unused surface cleanup: removed the dead
coreToolNames()helper and stopped exporting Agent constants/helpers that are private implementation details while retaining every internally used behavior. No compatibility placeholder or public CLI/MCP capability was removed.
2026-09-02 — MSO 1.12.0 sectioned Agent TUI + recoverable API failures
- Identity-first bottom composer: the old
[ask] ›prompt is replaced by the short durable handle (@milo ›). A full-widthInput · @milodivider separates transcript from editing state; permission moves to the dynamic footer asmode ask|auto|yolo, and empty-prompt Tab repaints only that footer. Wrapped input, resize redraw, prompt history, and keyboard editing remain intact. - Unambiguous transcript streams: streamed model text opens an
Assistantsection lazily on the first text delta, tool/subagent execution opensAgent work, and Local Agent send/receive/inbox output usesLocal agent. Sections are full-width and content is not duplicated merely to label a stream. - Recoverable error state: terminal API/transport failures carry bounded status/path/method/dispatch metadata and render a redacted
Errorsection. The turn journal distinguishesnot_started,completed, anduncertainmutation outcomes. A successful mutation is never repeated just because a later assistant request failed; an uncertain write/exec transport failure stops the turn before the model can retry it. - State preservation: recoverable failures keep the durable session/transcript/correlation rows, active draft redraw, and pending exact-approval metadata. Exact approval still binds the canonical full payload/digest; transport error rendering never prints request bodies, hidden transcript, credentials, or secret-shaped error values.
- Cleanup: turn/tool orchestration moved out of the CLI entrypoint into a focused module; the obsolete internal
permissionPromptandrenderStatusBarhelpers were removed instead of retained as compatibility shims.
2026-09-02 — MSO 1.11.0 named sessions + wrapped composer + collaboration observability
- Short session handles: every durable session now has a public
nameseparate from its longer title. Fresh sessions allocate familiar easy-to-type names such asmilo,luna, ornara; allocation is unique under same-principal concurrency, old sessions receive deterministic backward-compatible fallback names,/rename <name>changes only the handle, and/title <text>remains the topic/description lifecycle. Internalagent-apresence aliases remain a compatibility detail. - Active-name mentions: leading
@milo …resolves only currently active public names. Offline/ended targets are not mentionable; lower-level explicit mailbox sends retain backward-compatible offline queueing. The local directory reports lease status separately fromconsumerConnected/consumerCount, soidleno longer implies an SSE consumer exists. - Bounded request observability: added read-scope
local_agent_request_wait, returningreplied,target_offline,consumer_absent, ortimeoutin a bounded 0–30s foreground call without resend/background polling. The testing-handofflocal_agent_requestis now dispatch-covered as an exec-gated fresh bounded worker from another same-owner durable session context; it never claims to wake/control that original terminal/ChatGPT process. - Responsive composer: the interactive draft wraps to terminal width and a height-aware 2–12-row viewport. Terminal resize repaints without losing text; ↑/↓ navigate visual wrapped rows while preserving cursor column before falling through to prompt history.
- Compact exact approval: default ask-mode approval is one safe status line. Tab focuses it, Enter opens redacted-safe tool/scope/args plus the unchanged canonical SHA-256 digest, and a separate explicit
allow/denydecision is mandatory. Auto-write/YOLO still compute exact payload binding while skipping only the human prompt. - Subagent testing capacity:
OS_SUBAGENT_MAX_TURNSdefaults to 12 and can raise the server policy up to absolute 48; each child still defaults to 6 turns and remains foreground/context-isolated/non-recursive.
2026-09-02 — MSO 1.10.0 correlated Local Agents + same-session subagents
- Mention UX: leading
@agent-b …resolves the live/known local directory, validates aliases/manual labels, dispatches a durable correlated request, and returns an immediate honest acknowledgement instead of blocking on an idle target. Unknown/ambiguous mentions fail with stable alias choices; known offline targets remain queueable. - Explicit message contract: mailbox rows add backward-compatible
intent=notify|request|reply,correlationId,replyToMessageId, andrequiresUserRelay. Legacy sends remain notify-only;local_agent_replyinherits routing/correlation/relay policy from one exact inbox request. - Deterministic async relay: correlated replies are matched against a durable source
local_requestledger and become a synthetic assistant relay without another model turn. Notify-only/stale/mismatched/duplicate events never create extra assistant answers. - Processing semantics: SSE
deliveredno longer means processed. Requests remain unread until explicit ack/reply; replying marks the exact original request read. At-least-once SSE replay dedupes by message ID. - Subagent split:
/spawnandagent_subagent_runnow run transient foreground workers inside the parent session, not A2A child sessions. Workers start with isolated context, explicit objective/context only, read scope by default, 6/12 turn defaults/cap, 60/120s timeout defaults/cap, and final-result-only parent return. - Subagent guardrails: top-level exec approval is the explicit delegation boundary; child scope cannot exceed it. Recursive spawn plus
agent_session_*,agent_memory_*,local_agent_*, anda2a_*are unavailable inside workers. Legacymso a2a spawnremains the durable cross-session compatibility path.
2026-09-02 — MSO 1.9.0 native Local Agents
- Transport split: live same-host session communication is now a native Local Agents layer, separate from remote A2A v1. No Agent Card, URL, registration, bearer, refresh, or restart is part of local discovery/delivery.
- Automatic presence: interactive CLI sessions maintain a small private lease plus one SSE feed.
ready,idle,busy,offline, andendedhave explicit semantics; MCP conversation sessions refresh the same lease around bound tool calls. - Readable identity: unnamed live sessions receive stable per-principal
[agent-a],[agent-b], … aliases. Manualagent_session_rename//titlenames become primary immediately; duplicate manual names use a light alias suffix and ambiguous bare names fail instead of guessing. - Durable mailbox: explicit 16 KiB
message/taskpayloads persist privately before notification. Idle delivery can bedelivered/accepted, busy targets arequeued, and known expired/ended targets returntarget_offlinewhile retaining the message for a later receiver. - TUI:
/agents,/message, local/delegate, and/inboxuse the native layer. Incoming events redraw above an active composer without losing draft input, persist as roleagent, and project to a provider-compatible labeled envelope only when model context is built. - Tools/API: added
local_agents_list(read),local_agent_message_send(write),local_agent_inbox(read), plus owner-authenticated/api/v1/local-agents. Receiving a local message never expands tool/file/shell/network authority. - Isolation: directory/mailbox operations require the exact same durable-session principal; only explicit text plus minimal routing metadata is copied. Private stores use bounded 0600 atomic persistence and security-store locking.
- Remote compatibility: public A2A v1 registry, Agent Cards, credentials, send/task/handoff, inbound serving, and loopback compatibility helpers remain intact and are no longer the path used by native live-session UX.
2026-09-02 — MSO 1.8.2 constant-depth Agent restart
- Restart lifecycle fix:
/restartnow uses process replacement (execve) instead ofspawnSync. Repeated refreshes no longer leave prior Agent processes blocked behind their children. - Wrapper boundary: interactive
mso agentnowexecs its Node runtime, so the CLI wrapper itself does not remain as an extra waiting parent. A restart replaces the same process chain with the latestbin/msoand Agent modules while loading the exact same durable session id through a restart-only path; normal/resumecontinuation semantics remain unchanged. - Fail closed: runtimes without process replacement support refuse
/restartrather than silently falling back to a nesting child process. Node 22 on the supported MSO runtime providesprocess.execve.
2026-09-02 — MSO 1.8.1 Agent soft restart + new session
/restart: soft-reloads the interactive Agent process, not the MSO service/VPS. The current durable session is persisted, the composer closes cleanly, then the current CLI is relaunched with--resume <same-session-id>, so updated CLI modules plus the latest dynamic tool/skill/plugin catalog are loaded without abandoning conversation history.- Process-local UX: current permission mode and status-bar preference are forwarded only across this explicit soft restart and immediately consumed by the child; they are not persisted into durable session state or leaked to later child processes.
/new [name]: persists the current session, creates a fresh durable CLI session in the same terminal, clears conversation/queued-skill/usage state, and refreshes the capability catalog. An omitted name preserves normal first-prompt auto-title behavior.- Verification: lifecycle/session transition tests, slash/terminal contracts, permission/session regressions, TypeScript, targeted ESLint, and a real PTY soft-reload smoke test pass.
2026-09-02 — MSO 1.8.0 authenticated inbound A2A
- Shipped surface: A2A v1 outbound credentials/streaming plus authenticated inbound Agent Card and JSON-RPC/SSE server, with owner Settings → A2A management for peers, credentials, tasks, and audit activity.
- Authority model: inbound bearer profiles are owner-minted
read | write | execdelegated capabilities. Model-visible tools and MCP dispatch both enforce the scope; owner memory/session tool families remain unavailable to inbound callers. - Isolation: inbound tasks persist only explicit A2A messages/results, are isolated by credential principal, and use
taskIdas the MSO workflow session boundary so concurrent tasks cannot cross-control one another. - Credentials: outbound API-key/Bearer/OAuth access-token profiles live in private
0600storage and bind to sanitized Agent Card security schemes. Inbound raw bearer tokens are shown once and only their hashes persist. Unsupported query/cookie API keys, non-Bearer HTTP auth, mTLS, and multi-scheme AND requirements fail closed. - Streaming:
SendStreamingMessageandSubscribeToTaskuse SSE; observer disconnect does not cancel execution.CancelTaskremains the explicit cancellation boundary. - Ingress:
/.well-known/agent-card.jsonand/a2a/v1are machine-protocol surfaces with no document CSP/nonce or browser-cookie CSRF gate;/api/v1/a2aremains owner-cookie + CSRF protected. Public inbound serving is enabled when an explicit HTTPSOS_PUBLIC_ORIGINis configured;OS_A2A_INBOUND_ENABLED=0disables it. Same-host exact-loopback A2A is enabled by default and can be disabled withOS_A2A_ALLOW_LOOPBACK=0. - CLI:
mso a2a state,stream,auth ..., andinbound ...added; credential secrets are read interactively and sent through stdin rather than process argv. - Verification: targeted A2A/assistant/provider and ingress suites, typecheck, targeted ESLint, generated docs, and architecture/docs checks pass. Full release verification/build follows this entry before deployment.
2026-09-02 — Eval-gated Tool Forge P2 — SHIPPED
Cognitive Runtime P2 adds a self-improvement path without turning learned workflows into self-authorizing code. Four MCP primitives expose a private candidate lifecycle: tool_forge_candidates (read), tool_forge_propose (write), tool_forge_evaluate (exec), and tool_forge_promote (exec). Proposal requires P1 quality telemetry, at least two verified successes, at least 90% success, and a fully-completed best trace. Skill candidates contain only deterministic redacted tool guidance. Project-function candidates cannot generate shell/code or escalate a lower-scope recipe: they require an exec-scope verified recipe and may reference only an existing regular project-owned Node script; credential-like schema fields, fixture inputs, and fixed argv are rejected.
Executable fixtures run only in a dedicated local-only Docker sandbox: no registry pull, --network none, read-only root/project mounts, all capabilities dropped, no-new-privileges, non-root execution, and bounded CPU/memory/PIDs. bun run forge:sandbox constructs the minimal sandbox from the already-trusted host Node binary plus its shared libraries and labels it as MSO Forge v1. Evaluation rejects missing/unlabelled images and records the exact image ID plus project source SHA-256. Regression coverage proves fixture network access and project writes are blocked.
Promotion is intentionally high-friction: the caller must send literal PROMOTE <candidate_id>, MSO immediately re-runs the complete evaluation, candidate/target/toolset/source/image drift fails closed, existing Skills/functions are never overwritten, writes are atomic, and the resulting project capability is independently parsed/trust-checked. Combined with outbound A2A v1, MCP toolset 2026.09.02.4 contains 60 transport / 59 model tools (29 read, 23 write, 7 exec). bench:cognitive still reaches 100% required-tool routing recall while averaging 15.4 active tools / 11,614 schema bytes, a 72.0% reduction from the full catalog.
2026-09-02 — Interactive permission badge + outbound A2A v1 — SHIPPED
MSO CLI 1.7.0 makes permission state part of the interactive prompt instead of terminal scrollback. The bottom-left prompt is now a persistent color-coded badge (ask cyan, auto amber, yolo red); Tab on an empty prompt cycles ask → auto → yolo by repainting the same row with zero added LF/newline. The compact status line no longer duplicates permission. /permission remains the explicit picker/command surface, and the existing exact-call digest/server authorization semantics are unchanged. A live PTY regression proves three Tab transitions emit no scrollback line.
The same release adds a provider-neutral A2A v1 outbound client beside MCP. MSO discovers the standard well-known Agent Card, validates v1 supportedInterfaces, supports JSONRPC and HTTP+JSON SendMessage / GetTask / CancelTask, preserves optional tenant routing, bounds remote responses, and exposes a private host registry plus mso a2a / /agents / /delegate. MCP adds eight stable a2a_* tools for discovery/registry/message/task/handoff instead of dynamic per-peer tool names, and the per-turn router loads them only for A2A/delegation intent.
A2A is deliberately fail-closed at the trust boundary: only public HTTPS peers are accepted; the existing SSRF/DNS-rebinding pinned transport is reused; Agent Card security requirements are reduced to scheme names; authenticated peers are detected but not contacted until a dedicated credential profile exists. Normal messages carry only explicit A2A message/context/task arguments, while a2a_handoff carries only objective/context supplied by the caller plus optional one-way hashes—never hidden MSO history, memory, Skills, tool state, or raw session/workflow ids. Inbound MSO A2A serving, auth profiles, streaming/push and gRPC remain a later explicit phase rather than opening a network listener implicitly.
2026-09-02 — Full-store session resume resolution — SHIPPED
MSO CLI 1.6.2 moves direct resume resolution to the server-side durable session store instead of first truncating the candidate set to 100 recent summaries in the terminal client. --continue, --resume, /session <query>, and /resume <query> now resolve latest, modified-order index, full/short id, exact/prefix/fuzzy title against every owner-visible durable session; the interactive picker intentionally remains a bounded newest-first view for fast navigation. Empty default CLI shells are excluded from index/latest selection, matching the human picker. Ambiguity errors use human titles rather than exposing internal ids. Regression coverage includes a target beyond 275 synthetic recent rows so the 100-row regression cannot return.
2026-09-02 — Cognitive Runtime P1: typed memory + measurable agent quality — SHIPPED
P1 upgrades durable agent memory without breaking the existing USER.md / MEMORY.md contract. Each client principal can now persist a private records-v1.json ledger of semantic/episodic/procedural claims carrying confidence, sensitivity, validity windows, provenance authority/channel, supersession/retraction and competing-claim evidence. Legacy Markdown remains readable until the first structured mutation, then seeds the ledger and becomes a resolved compatibility projection. Resolution is deterministic by temporal effectiveness → authority → confidence → recency; future facts do not erase still-current facts early. MCP adds read-only agent_memory_search; raw ChatGPT conversation ids are never persisted in provenance.
Workflow learning now records P1 quality telemetry rather than only success and duration: completed/failed/denied/rate-limited/invalid-argument steps, retry count, rollback/restore signals and tool latency. Legacy recipes remain valid for aggregate workflow success but carry no qualityVersion, so the baseline correctly reports 0% step-telemetry coverage instead of pretending historical data exists. The current real recipe store is 179/186 successful workflows (96.2%); P1 telemetry coverage will grow only from executions observed after this release.
Benchmarking is now layered. bench:memory passes 8/8 deterministic retrieval/temporal/conflict fixtures; bench:cognitive reports 48 transport tools / 32,969 schema bytes, 14.5 selected tools / 11,125 bytes average, 66.3% reduction, 100% required-tool recall and 100% typed-memory fixture accuracy. bench:quality validates telemetry accounting and can summarize the live learned-recipe store. mso agent --oneshot <prompt> --json exposes the same autonomous tool loop without a TTY, read-only by default and requiring explicit --approve-scope for write/exec. bench:agents uses that runner plus Hermes/OpenClaw on a scratch-only read task and refuses comparison when model/provider evidence does not match. The first smoke passed MSO on GPT-5.6 Terra, while the local Hermes/OpenClaw configurations could not run the equivalent override, therefore comparable=false; no overall ranking is claimed.
The P1 smoke also caught a semantic tool-contract defect: sys_stats exposed uptime as an ambiguous numeric uptime field in milliseconds, which GPT-5.6 Terra described as days. The model-facing tool now emits explicit uptimeMs and uptimeSeconds fields and removes the ambiguous field while the existing REST/UI SysStats.uptime contract remains unchanged.
2026-09-02 — Human-first session picker + durable prompt history — SHIPPED
MSO CLI 1.6.1 removes the duplicate session navigation UI. /session and bare /resume now open exactly one native picker instead of printing a recent-session list and then rendering a second completion list. Sessions are sorted by updatedAt descending, the human title is the primary/only identity shown in the normal UI, and each row carries compact modified just now / Xm / Xh / Xd / YYYY-MM-DD metadata. The internal durable id remains the hidden selection value and an accepted exact query for automation/debugging. The Agent header, Runtime row, compact status bar, /session, and exit summary are title-first as well; /status deliberately retains the exact id for diagnostics.
Prompt history now behaves like a normal terminal across process boundaries, not only inside one invocation. On startup, --continue, or /resume, the composer is seeded from durable role:user rows newest-first, so ↑/↓ and Ctrl+P/N traverse prior prompts and return to the current draft. Session switching replaces the readline history with the selected session's prompts so histories do not leak across sessions. The existing Ctrl+C/D/L/W/U/K, Ctrl+A/E/B/F and word-navigation behavior remains unchanged.
The same audit fixed title lifecycle correctness. Fresh CLI sessions no longer send the placeholder MSO Agent session as an explicit manual title, allowing the first real prompt to auto-title the session. /title now calls the dedicated durable rename action instead of trying to smuggle a rename through an auto-title history update. A compatibility rule repairs only legacy CLI records whose literal default MSO Agent session was incorrectly marked manual; genuine manual titles remain locked. Regression coverage verifies newest-first ordering, hidden-id title rows, relative modified metadata, immediate dropdown rendering, durable ↑/↓ traversal, explicit rename, legacy-title repair, and human-title compact status. Real PTY proof covers one /session dropdown with no duplicate recent list/visible id, durable Up/Up/Down/Down traversal after --resume, and title-first banner/status output.
Permission DX is hardened in the same CLI patch. mso --yolo, mso -yolo, and mso agent --yolo all enter an explicit process-local YOLO mode; the default remains ask. /permission provides a native picker for ask, auto-write, and yolo, while Tab on an empty prompt cycles them. Auto-write only bypasses write prompts; YOLO bypasses both write and exec prompts. Crucially, non-read calls still compute the canonical full-payload approval object/digest before execution, so bypassing the human prompt does not bypass server-side exact-call binding. A real harmless exec_run PTY turn in YOLO completed without any allow this exact call? [y/N] prompt and with the server accepting the digest. The audit also makes /clear clear the composer prompt history, and filters empty default CLI sessions from the human picker so opening/exiting the Agent does not flood recent navigation.
2026-09-02 — MCP session lookup contention hardening — SHIPPED
The first live Cognitive Runtime P0 deployment exposed a scalability problem that unit-size fixtures did not: the host already had 2,927 durable agent session files, while every conversation-bound /mcp tool call still took one global session-store lock and scanned the entire directory to find its openai/session hash. Parallel ChatGPT conversations could therefore exhaust the 3-second security-store lock budget and return security store is busy; retry the operation even though each conversation was correctly isolated.
Conversation correlation now has a private durable index keyed only by the stable principal hash + hashed conversation id. Startup backfills pre-index P0 sessions once before requests are accepted; normal conversation lookup is then O(1). New-session creation uses a per-conversation lock so duplicate parallel calls collapse to one record, while history/title/event mutations use a per-session lock so unrelated chats never serialize behind a global lock. The raw OpenAI conversation id is still never persisted. Regression coverage runs 32 simultaneous lookups for one conversation, 24 unrelated conversations in parallel, legacy-index backfill, cross-session workflow isolation, compaction/archive policy, and MCP route correlation.
2026-09-02 — MCP-first Cognitive Runtime P0 — SHIPPED
MSO CLI 1.6.0 moves agent quality into the provider-neutral harness instead of relying on one model vendor. ChatGPT/MCP identity is now layered as authenticated client → durable conversation session → workflow/job: _meta["openai/session"] is hashed with the stable client principal and the raw opaque conversation id is never persisted, transport-session rotation does not split a ChatGPT conversation, active workflows/jobs are session-scoped, and verified learned recipes remain reusable at the stable client-principal boundary. This lets parallel chats benefit from prior successful procedures without being able to status, finish, cancel, or attach to each other's live work.
Durable session context now has an explicit lifecycle. MSO estimates stored context provider-neutrally, compacts at 700,000 tokens by default, preserves a structured summary plus roughly 140,000 recent tokens, writes a recursively redacted owner-only gzip archive before compaction, and prunes archives after 30 days both after archival and at boot. CLI continuation uses copy-on-resume across MCP/terminal surfaces. Separately, one model call receives only recent projected history—roughly 55% of the advertised context window, capped at 120k history tokens—so system policy, memory, active Skills/tools, reasoning and output retain headroom; assistant tool-use + matching result rows are projected atomically. /status distinguishes active model context from durable session/lifetime counters and compaction/archive counts.
Tool context is now budgeted at both schema and result layers. The public MCP transport remains capability-complete at 47 tools; the documented model/operator catalog is 46 tools (24 read, 17 write, 5 exec) plus app-only workflow_status. MSO's own terminal harness uses a deterministic per-turn router with a 14-schema soft target, core discovery/control tools, recently used tools and required companions. Generic MCP result text is capped at 32 KiB by default, exec_run at 48 KiB, and file/long-job outputs at 64 KiB; oversize results return a parseable msoTruncated preview/hint instead of flooding the model context. MCP toolset version is 2026.09.02.1.
bun run bench:cognitive is now a release-quality provider-neutral harness. On the release host, the full MSO catalog is 47 tools / 31,212 schema bytes, while 14 representative scenarios select 14.6 tools / 11,074 schema bytes on average, a 64.5% reduction, with 100% required-tool recall and deterministic routing. The installed Hermes v0.20.0 baseline reports 27 tools / 44,758 tool-schema bytes, so P0 is smaller on that exact comparable schema-footprint metric while preserving benchmark recall. This is deliberately not an overall Hermes claim. Installed OpenClaw 2026.7.1-2 has no directly equivalent offline prompt-size probe exposed to this harness, so no OpenClaw superiority claim is made yet; equivalent task-success, tool-error, token-per-success, latency and policy-compliance scenarios remain the proper overall benchmark target.
Final repository verification passes 271 test files / 1,972 passing tests with 1 expected-fail and 7 skipped. TypeScript passes; lint has 0 errors and only five existing max-lines warnings; value cycles are 0; docs report 49 current Markdown files and exact MCP parity; contrast has 0 WCAG failures; all 11 official skill flows validate; and the high/critical dependency audit is clean. docs/COGNITIVE-RUNTIME.md is the SSOT for these invariants and the P1 path: provenance/temporal typed memory, Tool/Skill quality telemetry, eval-gated Tool Forge, scope-preserving programmatic orchestration, and genuinely comparable Hermes/OpenClaw task-quality benchmarks.
2026-09-01 — External TTY Ctrl+C handoff hardening — SHIPPED
MSO Agent 1.5.8 closes one live-only SIGINT edge case found after the 1.5.7 deployment: cancelling the /model child TUI could leave the shared terminal in cooked mode, so the next Ctrl+C arrived as an OS SIGINT while the parent composer was awaiting a keypress. The interrupt manager correctly requested exit, but the waiting prompt was not resolved. AgentComposer now exposes one idempotent cancelCurrent() primitive shared by raw-key Ctrl+C and OS-level SIGINT. The parent SIGINT bridge wakes the current prompt on exit/interrupt, so child TTY handoffs cannot strand the Agent.
Regression coverage now includes programmatic cancellation of a waiting composer prompt in addition to the 1.5.7 raw-key and AbortController tests. Live PTY verification specifically covers /model cancel → returned Agent prompt → Ctrl+C clean exit.
2026-09-01 — Agent terminal control semantics + interrupt-safe history — SHIPPED
MSO Agent 1.5.7 aligns terminal control behavior with mature agent harnesses. Ctrl+C now clears a non-empty draft, exits cleanly from an empty idle prompt, and aborts an active assistant/tool HTTP turn through a real AbortController; a quick second Ctrl+C while a turn is still stopping requests exit. Ctrl+D follows readline semantics (delete-right with text, EOF exit when empty), Ctrl+L clears/repaints, Ctrl+W deletes the previous word, Ctrl+P/N mirror history ↑/↓, and Ctrl+A/E plus Ctrl+B/F provide standard line navigation. /quit is now an explicit /exit alias.
Interrupt state is split from the composer so raw-mode key handling and cooked-mode OS SIGINT cannot fight each other. Ctrl+C inside approval cancels and aborts the active turn, while Ctrl+C/Esc inside /model, /models, and /resume pickers cancels only that foreground picker. Assistant and agent-tool fetches receive the same turn AbortSignal. If a turn is interrupted, all user/assistant/tool history rows created by that unfinished round are rolled back before persistence; provider token usage already consumed may still be counted, but mso --continue never resumes a half-turn. Server-side bounded jobs already created keep their explicit job/cancel lifecycle.
Regression coverage includes empty/draft Ctrl+C, active-turn double interrupt state, AbortSignal propagation to the assistant fetch, Ctrl+D/W/L/B/F/P/N editing, /quit, slash catalog parity, and zero-warning modularity for the new control files. Real PTY smoke covers clean idle Ctrl+C/D exits, Ctrl+L repaint, draft-clear→exit, history recall, /resume cancel, both stages of /model cancel, /models cancel, and a real Codex turn interrupted back to a live prompt with historyTurns: 0. Final repository verification passes 265 test files / 1,953 tests, with 1 expected-fail and 7 skipped; typecheck, docs, dependency cycles and high/critical audit are clean, and the only lint findings are the six pre-existing max-lines warnings outside this change.
2026-09-01 — Arrow-key model/provider picker + visible skill lifecycle — SHIPPED
MSO Agent 1.5.6 removes the last numeric prompt from the AI provider/model interaction path. mso model, the no-argument mso models manager, provider connect/remove selection, and catalog-provider selection now share one dependency-free native TTY picker. The current provider/model is preselected, ↑/↓ redraw in place with zero added newline scrollback, typing filters candidates, Enter selects, and Esc cancels. Direct scriptable forms such as mso model openai-codex/gpt-5.6-terra and mso models add openrouter remain unchanged.
Skill invocation state is now explicit and consistent across the slash palette, /skills, the invocation badge and the compact status line: ◇ ready means trusted/executable, ◆ queued means selected for the next message, and ✓ invoked means the skill instructions were actually attached to a model turn. Queued state is amber; invoking/invoked state is green. Resuming or clearing a session clears ephemeral skill UI state so one session cannot visually leak the previous session's skill marker.
Regression coverage locks the picker/filter/wrap primitives, absence of numeric model/provider prompts, exact /model vs /models behavior, skill ready/queued/invoked state, and status propagation. Real PTY smoke verifies model current-item highlighting, ↓/↑ with zero LF output, Esc cancellation, and preservation of the active model.
2026-09-01 — Agent model/session UX parity + dynamic status — SHIPPED
MSO Agent 1.5.5 aligns the useful interaction contract of mature agent harnesses without copying their branding/runtime. The startup banner now uses the owner-specified 12-line Hybrid MSO geometry and exact six-stop True Color gradient (purple/indigo → blue → cyan → teal/emerald). AI configuration is split into two explicit surfaces: mso models manages provider API keys/OAuth/custom-provider connections without switching the active model, while mso model validates and selects only models available through connected providers. Exact /model now wins over the /models prefix in the slash palette; OpenRouter-style model IDs containing / are resolved against the current provider before being interpreted as a provider/model ref.
The terminal now carries a compact dynamic status line with active provider/model, approximate context consumption (explicit ~, plus catalog context window when known), provider-reported token usage when available, turn count, last-turn latency, durable session id and working directory. /status//context expand the same state and /statusbar toggles it. Session UX supports /title, numbered /sessions, /resume picker, latest, index, exact/short id, exact title or unique fuzzy title; startup equivalents are mso --continue and mso --resume <query>. Resume stays bounded to sessions visible to the authenticated principal. Anthropic and ChatGPT/Codex streaming now propagate provider usage into the terminal status when upstream data exists; OpenAI-compatible streams consume usage opportunistically and otherwise keep the clearly-labeled estimate.
The same audit caught two real regressions before release: /api/models/test could not validate the openai-codex subscription provider because it incorrectly entered the generic API-key resolver, and Enter on exact /model could apply the highlighted longer /models completion. Both paths now have dedicated regression tests. Provider-auth APIs accept select:false for CLI connection management while keeping legacy Settings callers selecting by default, so existing browser behavior remains compatible.
Verification for this milestone passed 262 test files / 1,939 tests (1 expected fail, 7 skipped), typecheck, documentation consistency, cycle checks and high/critical dependency audit. PTY smoke covers exact 12-row banner/color output, wide/narrow terminal behavior, zero-newline arrow navigation, /model vs /models, /status, durable title, resume by title and --continue.
2026-09-01 — Version identity and update messaging DX — SHIPPED
MSO's two legitimate version domains are now explicit instead of looking like drift. The app/package
version remains the runtime/service compatibility identity used by health/readiness and Settings → About;
the CLI keeps its independently versioned interaction contract. mso --version labels CLI, app
and the exact Git build, About says App version, and README/install docs explain why those values
can differ. Git commit identity remains the release/update authority.
mso update status and its interactive background notice also distinguish a CLI-version change from a
commit-only release. A commit-only update now says N new commits on mso CLI X instead of the confusing
X -> X; a true CLI bump still shows an explicit mso CLI X -> Y. Up-to-date status labels both CLI and
build identity. Regression tests cover version-change, commit-only, active-service build matching and CLI
version output so the ambiguity cannot silently return.
2026-09-01 — Terminal banner geometry + stable slash navigation — SHIPPED
MSO Agent now uses the compact canonical folder + MSO ASCII geometry from the terminal logger instead of the oversized 12-row title. The seven title rows render as a cool blue → cyan → teal/emerald gradient with no purple. The slash palette also reserves its physical terminal rows only when it opens or grows; subsequent ↑/↓ selection redraws use ANSI cursor movement only, and the input prompt no longer embeds a leading newline that would be replayed on every redraw. A real PTY regression verifies both arrow directions emit zero LF/CRLF while still moving selection, so terminal scrollback stays stable. CLI patch version: 1.5.4.
2026-09-01 — Install/update DX and legacy upgrade bridge — SHIPPED
The public installation contract is now explicitly agent-friendly and backward-compatible. A user may
hand a capable AI agent only the MSO repository URL and ask it to install or update; AGENTS.md,
CLAUDE.md, README and the public /install page all route that request to the repository-owned
installer/updater instead of a hand-built parallel setup. Current installs use mso update or Settings →
About, while older installs that predate both surfaces bridge forward by re-running the same verified
one-line installer. The installer discovers an existing mso.service WorkingDirectory before selecting a
default checkout, preserves .env.local and ~/.mso, refuses dirty/diverged source, and upgrades in
place rather than creating a second clone.
README's Useful installer controls now covers every public flag and environment override advertised by
install-core.sh, with safe guidance for bind/ref overrides. A new contract test derives those controls
from --help and fails when README or docs/INSTALL.md drifts. Upgrade completion is also state-aware:
fresh installs receive first-device pairing guidance, while existing installs say updated, confirm
preserved state, and point to mso update, Settings → About, mso doctor, onboarding and the legacy
installer fallback without replaying first-run instructions. Repository worktree policy was consolidated
at the same time: ~/projects/mso/origin/main remains the release SSOT and parallel worktrees stay under
~/.cache/mso-worktrees until verified and reconciled.
2026-08-31 — MSO terminal agent + provider-backed deployment setup — SHIPPED
Shipped milestone. The release passed the repository/security gates and the live health endpoint returned the release build SHA before this status was promoted. A previously standalone deployment-assistance pattern is now absorbed into MSO's own architecture instead of spawning a second agent runtime. Installed Hermes and its public CLI were used as interaction references only; MSO has original terminal artwork, its own tool catalog, and its existing auth/audit model.
What changed:
- bare
msonow launches MSO Agent;mso agent/mso chatare explicit aliases andmso modelconnects or changes the AI provider before the agent starts; - the terminal presents an original MSO folder +
>_ASCII icon beside the large MSO wordmark (stacking on narrow terminals), selected model, Available Tools, Available Skills and infrastructure readiness, then streams through the existing/api/assistantbackend; - the terminal discovers the canonical MCP catalog through an Owner-only
/api/v1/agent-toolsbridge. Read tools may execute directly; every individual write/exec call pauses for an exact-call terminal approval (never a cached session-wide mutation grant) while server role/scope/rate-limit/audit checks remain authoritative; - MCP toolset is 2026.08.31.1: 38 tools = 20 read + 13 write + 5 exec. New provider tools cover redacted provider discovery/doctor, Dokploy project list/ensure, exact per-record Cloudflare DNS upsert, and exact Hostinger name/type RR-set replacement;
- provider credentials are stored separately in
~/.mso/private/infra-providers.json: 0700 parent, 0600 file,O_NOFOLLOW, regular-file/owner/size checks, atomic locked writes, API summaries expose only the wordconfiguredfor secret fields, and no raw secret enters model/MCP arguments; mso provider set dokploy|cloudflare|hostingeruses hidden terminal input. AI API-key setup was hardened at the same time so provider keys are built from stdin rather than being exposed through helper-process argv;- Dokploy and Cloudflare are built-in default shell/App Store features with secure configuration, Verify, and live project/zone inventory. Hostinger remains a provider rather than a default app;
- configurable remote Dokploy endpoints use the existing DNS-pinned safe-provider transport; remote HTTP is refused, redirects are refused, and private/link-local/metadata resolution is blocked. Literal loopback remains the explicit same-host exception;
- Cloudflare automation never performs a bulk zone PUT, refuses duplicate/conflicting rows, PATCHes one existing record or POSTs one new record, and defaults proxying off. Hostinger DNS now uses the provider's scoped RR-set replacement semantics (
overwrite:truewith onename + typerow), so unrelated zone rows never enter the PUT payload; ambiguity/conflicts remain refused and the mutation stays approval-gated; - official
mso-project-deployskill documents workflow start → inspect → provider doctor → bounded deployment/DNS operations → runtime/HTTPS verification → finish/cancel; - MSO Agent slash skills are now executable:
/<skill>selects a trusted global/current-project skill for the next message,/<skill> <prompt>runs immediately,/skill <exact-id>resolves cross-project ambiguity, and Tab completion only offers skills valid in the current scope; project skills follow the terminal working directory while untrusted instructions remain withheld; - the terminal composer opens a Hermes-style slash dropdown immediately on
/, with live filtering, fixed 8-row viewport, Enter/Tab selection, Esc dismissal, command metadata, and trusted current-project/global skill recommendations; mso updatenow short-circuits when source and active runtime already match, avoiding redundant production rebuilds; when a real service update is needed, an interactive terminal waits and prints update milestones until the new runtime is verified instead of immediately returning with only a log hint;- CLI version for this interaction milestone is 1.5.4.
docs/INFRASTRUCTURE-PROVIDERS.md, architecture/install/MCP/ChatGPT connector docs, generated CLI reference and slice catalog are synchronized.
Verification added specifically for this slice covers provider-store symlink/permission/secret behavior, Cloudflare one-record semantics, Hostinger exact RR-set payloads, Owner-only agent/provider routes, exact-payload terminal approval, CLI onboarding/update fixtures, MCP parity/rate limits, and documentation/toolset markers. The final full repository gate passes with 254 test files / 1,918 passing tests (1 expected fail, 4 skipped), typecheck and dependency audit green, zero value cycles, and zero lint errors (six pre-existing max-lines warnings remain). A targeted Codex Security pass first found two Medium issues in the new infrastructure surface — whole-response buffering before its nominal 1 MiB cap and a stale full-zone Hostinger PUT. Both were fixed; the final infrastructure re-scan completed 1/1 component with 0 findings. A separate terminal-agent scan found one Medium issue where a truncated approval preview could conceal mutation fields. The terminal now renders the complete canonical tool name + nested input, refuses approval payloads above 32 KiB, removes session-wide mutation grants, and binds the approval SHA-256 to the exact payload that the server independently re-hashes before dispatch; the final terminal-agent re-scan completed 1/1 component with 0 findings. A parallel-suite-only lifecycle harness race was also removed by holding the fixture lock until the assertion explicitly releases it; the lifecycle file then passed 5 consecutive runs (40/40 checks). The first production handoff also exposed a release-verification false negative: the system unit can spend close to its 90 s TimeoutStopSec draining the old npm/Next control group, while the finalizer only waited 40 s for a new MainPID. Production still reached the gated release SHA, and the verifier now uses a bounded 120 s default restart budget (override constrained to 30–300 s) so a valid slow systemd restart is not reported as rollback. Live Dokploy/Cloudflare/Hostinger API success is intentionally not claimed until an owner supplies credentials and mso provider doctor checks that provider.
2026-08-31 — Login-origin diagnosis + mso doctor --fix + runtime hardening (SHIPPED)
A real install report confirmed the confusing post-approval login case was transport, not a broken
device store: the browser was opening MSO on plain http://<server-ip>:4005. MSO's session cookie is
always Secure, so that address can answer health/API requests and accept the password while the
browser still cannot retain the authenticated session. Pairing on that IP and later moving to an HTTPS
hostname is also a different browser origin, so the device ID shown there is not the final-origin ID.
The supported guidance is now explicit in the installer summary, /install, README, CLI reference,
Install and Troubleshooting docs: browser sign-in uses HTTPS, or loopback via http://localhost (for
example through SSH port forwarding). mso doctor prints the same login-transport rule even when its
own loopback CLI base is healthy, and fails clearly when --base / OS_PUBLIC_ORIGIN points at a
plain-HTTP non-loopback address. mso doctor --fix was added for bounded local recovery: it may start
an existing MSO service, approve this host's own CLI device, and refresh its session jar; it never
changes DNS, certificates, firewall rules, public exposure, or login credentials.
The screenshot also exposed a separate onboarding bug: ensure_local_cli_device previously searched
device --list, which contains both APPROVED and PENDING rows. A CLI ID already in PENDING was
therefore mistaken for approved, onboarding skipped promotion, then its first authenticated request
failed. The device helper now has an exact approval-status probe; onboarding and doctor promote that
local CLI ID correctly and regression tests cover the pending-to-approved case.
The remaining changes from PR #28 were not discarded as stale. Its installer/update-lock recovery, service/fallback readiness handoff, gateway public-origin canonicalization, job-retention ordering and security-store contention fixes were integrated on top of the current MCP work and independently exercised before release.
2026-08-31 — Guided multi-client MCP setup in Settings (SHIPPED)
Settings → MCP now treats connection as an onboarding workflow instead of a developer-only list of
OAuth endpoints. The authenticated Settings API returns MSO's deployment-owned public origin, so a
loopback browser no longer teaches ChatGPT a localhost URL when OS_PUBLIC_ORIGIN is configured.
The connection card probes GET /mcp, the Bearer OAuth challenge, protected-resource metadata and
authorization-server metadata and reports readiness only when all four agree on the same deployment.
The UI now mirrors modern MCP client setup flows: choose ChatGPT, Codex, Claude Code, Cursor, Gemini
CLI, VS Code, or a generic Streamable HTTP client; follow numbered steps; copy the exact server URL,
CLI/config snippet, and only expand advanced OAuth fields when a client asks for them. ChatGPT gets
copy-ready Name/Description/Connection/Authentication values matching the New Plugin form. Local-only
origins are called out before users paste them into a cloud client, with MSO Gateway and stable
custom-domain/reverse-proxy instructions that keep the raw Next listener loopback-only. Scope guidance
starts at read and explicitly describes write and exec blast radius.
The existing token revocation, audit trail and toolset-signature cards remain the operational truth
after connection. Current MCP/ChatGPT docs were refreshed at the same time, including the live
31-tool split (16 read / 10 write / 5 exec) and current Plugin/App terminology. The Streamable HTTP
route now also validates browser Origin before authentication, closing the DNS-rebinding gap called
out as a MUST in the MCP transport specification, while server-to-server clients remain unaffected.
2026-08-31 — 10× MCP daily allowance + truthful Settings updater preflight (SHIPPED)
The authenticated MCP endpoint now permits 50,000 calls per token per fixed 24-hour process-local window, up from 5,000, while retaining the 120-per-minute runaway-client guard. The public MCP tool names, schemas, scopes and toolset signature are unchanged; this is an endpoint limit only.
Settings software update now refuses non-main checkouts before starting its transient updater,
matching the CLI contract and preventing a feature branch from being misreported as merely one
commit behind origin/main. The executor independently enforces the same branch boundary, and the
panel no longer labels an unsupported checkout as a remote-connectivity failure.
2026-08-30 — Loopback-only public gateway + resilient WSL CLI lifecycle (SHIPPED)
MSO now has an explicit laptop/WSL public-access lifecycle without widening the application bind.
mso web verifies the MSO health contract and can start the already-built production runtime on
127.0.0.1 when no service is active. mso gateway start adds an outbound HTTPS Cloudflare tunnel
on top; temporary Quick Tunnel mode is disclosed as preview-only because the provider does not
support SSE, while named/custom-domain mode remains driven by OS_PUBLIC_ORIGIN. mso gateway domain set https://… updates that stable origin atomically and prints loopback-only ingress config.
The independent PR review found lifecycle failure modes before merge, so the gateway was hardened
rather than those comments being dismissed. Gateway state now records a process fingerprint (PID,
/proc start ticks, executable and command-line hash), startup first verifies the exact expected argv,
stop refuses identity mismatches, start/stop share an owner-only lifecycle lock, concurrent starts
produce one tunnel, state-write failure rolls newly launched processes back, stale tunnel state
preserves a still-owned runtime, and both local/public probes require MSO's structured health
contract rather than accepting any HTTP 2xx. The original 428-line script was split into bounded
≤200-line single-responsibility modules. Regression tests cover rollback, PID reuse, concurrency,
runtime ownership, non-loopback/hostname confusion, config permissions, domain mutation and browser
selection.
The WSL onboarding failure path is also repaired. mso onboard no longer turns a connection failure
into the false advice to approve an already-approved device; loopback onboarding starts/verifies the
fallback runtime first. Re-approving the same device+role is idempotent, while role changes still need
mso device role. CLI version is now 1.4.0. mso update is API-independent and is the preferred
operator command: it can fetch/fast-forward/verify/build even when port 4005 is down, and normal
interactive CLI use emits a throttled Git-backed update notice when origin/main is ahead.
mso update run remains accepted for compatibility. Final PR review then hardened crash/concurrency
recovery: deployment state is keyed by canonical checkout, update transactions are serialized with kernel flock, recovery intent is durable before an owned runtime is quiesced,
and an interrupted post-quiesce state write is reconciled on retry. The shared private-state atomic
writer now propagates write/rename failures explicitly even when called from a shell conditional. A
full pre-push run then exposed a fork/signal race before the tunnel fingerprint existed. Tunnel launch
now uses a held-child handshake: the scrubbed child cannot exec cloudflared until its parent records
PID + kernel start-ticks and releases an owner-only gate; if the parent disappears first, the child
self-terminates. The same handshake now protects the detached Next fallback. Final review also moved
gateway/update serialization to kernel flock (no stale-lock ABA reclaim), scoped gateway state by
canonical checkout + selected loopback origin, and made public readiness compare the exact local
version + buildId + runtimeInstanceId. This closes the cross-clone control and wrong-deployment
readiness classes without widening the raw app bind. The last P1 review pass added a checkout-wide
shared/exclusive runtime exclusion: every in-place update owns it exclusively through .next mutation and deployment-state persistence, while all runtime-start paths take the shared side. Service-active updates now inventory and restore all gateway-owned fallback origins for the checkout instead of assuming only one runtime exists. An already-live
tunnel is no longer treated as sufficient proof of readiness; gateway start recovers a dead local
runtime, preserves the tunnel PID, and re-probes the exact public health identity before success.
The global response policy additionally sends X-Robots-Tag: noindex, nofollow, noarchive because an
MSO control plane should not be indexed merely because a temporary HTTPS endpoint exists. The
Cloudflare client is now a core supply-chain lock too: release 2026.8.2 is pinned by exact official
asset URL + SHA-256 for Linux amd64/arm64, installed user-locally on first gateway use, re-hashed
before reuse, and launched with self-update disabled. Named configs are parsed before launch and are
accepted only when dedicated to the configured MSO hostname/loopback port with a private credentials
file and a terminal http_status:404 fallback.
2026-08-30 — WSL Bun bin-metadata build resilience (SHIPPED)
A second real Ubuntu/WSL install reached checkout and a complete Bun 1.3.14 dependency install,
then failed at bun run build with could not open bin metadata file / Bun failed to remap this bin. The important distinction is that Bun's package-bin metadata can be damaged while the actual
node_modules/next package payload remains readable. The previous ordering also meant this build
failure still happened before the CLI launcher was created, so an operator again ended with no
mso -h despite a valid checkout.
The installer now treats the CLI as the earliest post-checkout recovery surface: it creates and
self-checks the launcher before dependency installation, configuration, build, or service setup.
Production build no longer asks Bun to remap the next package binary; it executes
node node_modules/next/dist/bin/next build directly. A force reinstall is reserved for the
stronger condition that the package entrypoint itself is missing after dependency installation.
This keeps real compile errors fail-closed while avoiding a WSL-specific package-bin indirection.
Regression coverage asserts the new phase order, forbids an executable bun run build in the
installer core, and proves the direct Next entrypoint still runs while node_modules/.bin/next is
absent. A WSL-like end-to-end run using Bun 1.3.14 deliberately replaced .bin/next with a failing
launcher immediately after dependency installation; the production build still completed through
the direct Node entrypoint, the broken launcher remained broken (proving it was not silently fixed),
and the parent shell resolved mso -h successfully.
2026-08-30 — WSL installer reliability and recognized property fuzzing (SHIPPED)
A WSL install exposed two assumptions that were true on the production VPS but not on a fresh
Linux shell. The installer treated the presence of a systemctl executable as proof that systemd
was PID 1, and it did service setup before creating the CLI launchers. On WSL with systemd disabled,
systemctl therefore aborted the set -e installer before mso existed. Separately, curl | bash
can never modify the parent shell's PATH, so claiming mso -h was immediately available without
checking the invoking PATH was not a valid installation contract.
The installer now creates and validates the CLI before service setup, requires systemd to actually
be PID 1, persists ~/.local/bin for future bash/zsh sessions, and uses a guarded launcher in an
already-reachable system bin directory when possible. It checks the original invoking PATH rather
than its child-process PATH and prints an exact fallback export when immediate discovery cannot be
proven. WSL without systemd remains a supported CLI-only shape; background service/onboarding waits
for a verified service. An isolated clean-HOME/PATH install proved the child installer returns to a
parent shell where command -v mso and mso -h succeed. The invoking cwd is captured too: relative
PATH entries such as bin are normalized against that cwd before discoverability is claimed, so a
later cd into the checkout cannot manufacture a false positive.
The service readiness gate was also corrected for explicit NEXT_DEPLOYMENT_ID. Each installer-
driven service restart now receives a fresh random runtime instance ID in the systemd unit, and the
public no-store health route echoes that non-secret value. Readiness accepts the response only when
it carries the exact freshly injected ID. This is stronger than either build-ID or MainPID change:
it still works when the deployment ID intentionally stays stable, while a stale or unrelated process
that happens to answer on the same port cannot satisfy the gate. Runtime reporting also
distinguishes “WSL without systemd” from “systemd existed, the unit was attempted, but health/takeover
verification failed,” so a failed WSL service keeps its journal recovery path instead of being mislabeled.
OpenSSF's remaining Fuzzing posture gap is addressed with real TypeScript property testing rather
than a dismissed alert. fast-check now generates adversarial cases for filesystem containment,
private-provider SSRF rejection, and PKCE exactness; the package/import form is one that Scorecard's
Fuzzing check recognizes. Code Review and CII Best Practices remain external governance evidence:
they require genuine independent review and OpenSSF badge enrollment rather than repository-side
alert suppression.
Verification: installer Bash syntax + hosted ShellCheck, installer contract tests, hundreds of property-generated security cases, full TypeScript/lint/test gates, docs/changelog parity, dependency audit, isolated production build, an isolated clean-HOME/PATH install, and protected-branch hosted CodeQL/dependency/Gitleaks/Trivy/OSV/Semgrep checks.
How to read this log: it is the source of truth for why/when work shipped, not today's API/runbook. Phases 0–14 were built on Convex self-hosted + a legacy control-service host-agent bridge; that stack was removed in Phase 15 and later entries describe the self-contained Next.js/
lib/hostarchitecture. For the current implementation start atdocs/README.mdanddocs/ARCHITECTURE.md; keep old entries intact as historical evidence even when their commands/counts have been superseded.
2026-08-30 — atomic installer bootstrap for WSL / partial-transfer safety (SHIPPED)
A real WSL run of the documented one-liner exposed a gap the earlier isolated tests missed: the
large scripts/install.sh was executed directly from the network stream. Replaying only the first
11,981 bytes of that file reproduced the report exactly — Node and Bun printed as healthy, Bash
reached a syntactically complete EOF and returned 0, but checkout/CLI installation never ran.
A partial HTTP response could therefore look like a successful install even though mso -h did
not exist.
The public scripts/install.sh is now an intentionally small bootstrap. It downloads the complete
scripts/install-core.sh to an owner-private temporary file first, retries the transfer, requires
a minimum payload size and exact EOF marker, verifies the committed SHA-256, runs bash -n, and
only then hands off with a final exec. The fail-closed EXIT trap is the first executable
statement after the shebang, before comments or variable setup, and there is deliberately no
earlier "done" assignment. Every later syntactically complete network prefix therefore becomes a
non-zero truncation failure instead of a false success; a regression includes the exact early-prefix
shape (head -n 16) that independent review used to reproduce the remaining gap. The core carries phase-only error
reporting (no raw command/secret echo). A second clean-image reproduction found that bin/mso also
requires jq: Node and Bun alone were not enough, and the old installer never installed that CLI
runtime dependency. The core now verifies/installs curl, jq and the required coreutils before
creating the launcher, then separately proves the target is executable and that mso -h succeeds.
The existing WSL contracts remain intact: CLI setup precedes service setup, PID 1—not the presence
of systemctl—decides service availability, caller PATH/cwd semantics are preserved, custom bin
paths are reported honestly, and installer-driven service readiness is tied to a fresh runtime
instance ID. Contract tests execute the local bootstrap/core pair and prove that a syntactically
complete truncated payload is rejected.
2026-08-29 — evidence-backed comparison, delegated roles and Service Center (SHIPPED)
The old README comparison mixed unrelated tools into one hand-written scorecard. It is now generated
from docs/comparison-data.json: six defined criteria, official-source links for every comparison
product, an existing repository-evidence requirement for every MSO rating, explicit searchable
status words (Strong, Partial, Not offered) instead of icon-only cells, and a 90-day review
freshness gate. The chosen category is deliberately narrow—mobile-first, AI-native private Linux
workspace for an owner or small trusted team—while specialist strengths and unfinished gaps remain
explicit in docs/COMPARISON.md and docs/COMPETITIVE-ROADMAP.md.
Device approval now carries a live Viewer, Operator or Owner role. The store migrates legacy role-less devices to Owner, fails malformed roles down to Viewer, prevents browser self-demotion and last-Owner removal, and re-resolves role/revocation on every request. The shell filters inaccessible apps for clarity, while a centralized server policy makes the actual decision: explicit reads are Viewer and every unclassified route fails up to Owner; PTY/exec/config/MCP/update remain Owner, and only explicit bounded operational surfaces are Operator.
A hosted CodeQL follow-up on the first release candidate was not treated as cosmetic backlog.
The release was reopened to harden validated config maps, strict thread identifiers, external iframe
policy, descriptor-bound file reads, dual root containment, private collision fixtures, bounded
models.dev cache writes, exclusive upload staging, and immutable CodeQL workflow pins. The first
PR rescan then reported eight changed-line alerts rather than being called green because the
analyzer process exited successfully: a password-comparison model, five path/race flows, one test
TOCTOU and the intentional ChatGPT file-transfer sink. The comparator now uses fixed-width bytes
without creating a stored/fast password hash; thread IDs and host paths use explicit path.relative containment, with every host
filesystem sink kept inside the analyzer-recognized safe branch; the cache test binds mode and read to one file
descriptor; and the ChatGPT bridge now streams under 20 MiB, validates redirect host, MIME and raster
signatures, then enters the guarded atomic upload path. Its remaining network-to-disk data flow is
the documented purpose of fs_upload_file; it may be classified only as reviewed won't fix, never
as a false positive or by weakening CodeQL. Regression tests accompany each changed boundary; the
replacement SHA must repeat the full repository, build, hosted-analysis, deploy and
ultimate-assurance gates before the branch is considered closed.
The same release reconciles all ten open Dependabot PRs instead of merging them blindly. Seven
minor/patch or action updates with green hosted checks are integrated, and Lucide 1.x is migrated
with its removed GitHub brand glyph replaced by a supported repository glyph. ESLint 10 and
TypeScript 7 remain on a documented compatibility hold because the current Next.js React lint
plugin crashes under ESLint 10 and the current typescript-eslint stack rejects TypeScript 7;
Dependabot now suppresses only those semver-major repeats while continuing minor, patch, and
security updates.
System Monitor now includes Services and Updates beside live telemetry. It inventories system/user
systemd units, bounds journals, and permits start/stop/restart only for validated exact units in
OS_SERVICE_CONTROL_UNITS; no shell or wildcard path exists. Package visibility reads only the
existing local cache for apt/dnf/yum/pacman/zypper and exposes no refresh/install/upgrade action. The
same contracts are available through mso units, mso unit ..., mso packages, and role-aware
device CLI commands. Current-reference docs, env examples, generated CLI/comparison docs, Product
Hunt copy, contributor rules and security boundaries were synchronized in the same release.
Release contract: the exact commit must pass repository verification, an out-of-tree production
build, bun run ship, deployment, live health checks and the project security gate. The release
record below is generated from that immutable commit rather than from an uncommitted worktree.
2026-08-28 (security) — full-repository Codex remediation (DONE)
The first terminal Codex Security component review completed all 20 tracked-repository partitions and produced one High, sixteen Medium and three Low groups. Every reported group was traced to its actual boundary and remediated rather than suppressed: MCP now authenticates before bounded JSON parsing and reapplies the deployment scope ceiling on every call; durable Alfa memory requires approval of the exact text; learned recipes are actor-isolated; skill discovery is symlink-safe with authenticated, bounded cursors and one bounded semantic query embedding; and mutation approvals disclose the complete canonical arguments.
Browser and media boundaries were hardened as well. Camoufox/noVNC moved off the cockpit origin to a dedicated authenticated host, strips cockpit credentials, and is torn down when a device is revoked. Custom provider connections resolve and validate every destination and redirect against private, loopback, link-local and metadata ranges. Image-editor projects and Reel media now enforce finite dimension, byte, sample and duration budgets before canvas allocation, decode or export. CLI/editor cookies and documents live only under verified owner-only 0700/0600 state with atomic no-symlink writes. Security-store stale recovery now uses one shared acquisition gate across web and CLI writers, closing the check/unlink ABA race.
Managed-app execution identities are immutable: Hermes installer bytes and checkout commit, the
exact OpenClaw package, and the 9Router OCI digest are committed and verified before execution.
9Router binds loopback unless public exposure is explicitly enabled. The release remains
fail-closed: full regression, isolated build, all 20 Codex components, passive ZAP, scanner gates,
push gates and exact-SHA production health must all terminate successfully before main is
promoted; skipped lanes are never reported as the ultimate result.
2026-08-28 (mcp) — bounded async exec jobs (DONE)
Added exec_job_start, exec_job_status, and exec_job_cancel so long test/build pipelines no longer need systemd-run/sentinel-file orchestration around the 30-second exec_run request limit. Jobs reuse the cwd jail and destructive-command filter, are actor/workflow-bound, capped at 20 minutes and four concurrent jobs per actor, cap each output stream at 1 MiB, and retain completed state for 30 minutes. Toolset is now 1.6.0 / 2026.08.28.1: 31 tools (16 read, 10 write, 5 exec).
2026-08-27 — systematic reverse-engineering + MCP feature playbook (DONE)
Implementation work now has one durable default across Claude, Codex/general agents and MSO: resolve the canonical source/runtime first, reproduce and preserve evidence, map the end-to-end pattern and limits, compare a working analogue, test one hypothesis at a time, make the smallest reversible change, and prove the exact live outcome. This prevents the repeated failure mode where an agent edits a temporary clone, retries a connector with the same invalid shape, stacks several speculative fixes, or reports success from a build without checking the running feature.
docs/MCP-FEATURE-IMPLEMENTATION.md records the complete MCP implementation contract for tools,
trusted skills and project functions: public schema/name stability, scope, thin lib/host
delegation, audit metadata, limits/cursors, Alfa parity, toolset signature, external mappings,
client action refresh, trust/id routing, release handoff and layered runtime/browser proof. The
new official mso-mcp-feature-engineering skill makes that workflow searchable and reusable,
while root AGENTS.md gives non-Claude agents the same repository routing. Global agent
instruction files point to the same pattern; volatile host facts and secrets remain outside the
skill and repository policy.
2026-08-25 — 9Router configured-domain UI + official icon correction (DONE)
The first public-IP fallback pass made the fallback the preference: because every managed
9Router container publishes port 20128, publicDashboardUrl was always present and the UI
selected it before the already-configured split-origin host. On deployments such as this one
with {id}.mso.example.com, that replaced the real in-shell dashboard with a card that only
opened a new tab. Source precedence is now explicit: configured split-origin domain first,
public IP only when no embeddable domain exists. UI therefore renders the 9Router dashboard
inside the same managed-feature iframe shell as Hermes/OpenClaw.
9Router also no longer uses the generic Lucide Route placeholder. MSO copies the official
/app/public/icons/icon-512.svg from the current 9Router Docker distribution into its local
official-brand asset set and uses it in the shell, launcher, window and Details cards. The
legacy standalone deployment guidance now records the same
existing-domain-first/public-IP-fallback contract so future automation does not recreate this
regression.
2026-08-25 — 9Router public-IP-first managed-app correction (DONE)
The first 9Router managed-app pass incorrectly coupled the app surface to MSO's optional
split-origin hostname and documented 9Router as Docker-only. Live inspection disproved both
assumptions: the existing container was healthy on host port 20128 and the older standalone
hostname still worked, while the new 9router.mso... path was an authenticated MSO proxy;
upstream also ships a real npm 9router CLI. The result made a healthy app look like a DNS
problem and generated an invalid 9router status terminal command.
The managed server runtime remains Docker by design (upstream's VPS path), but domain/DNS is
now explicitly optional. Definitions can declare a public host port; MSO derives a global
IPv4 locally and advertises 9Router at http://<public-ip>:20128. The UI opens that endpoint
as a separate top-level origin rather than attempting insecure same-origin proxying or an
HTTP iframe inside HTTPS. The CLI view starts with read-only Docker logs and never launches a
second 9Router process. Existing standalone domain routing is left untouched. Install/update/
uninstall continue through the Docker adapter and preserve ~/.9router; dry-run removal is
part of the verification path.
Current managed-app, install, architecture, troubleshooting, env, README, and dedicated 9Router documentation now agree on the three-layer model: runtime management requires no domain; direct public access is available where intentionally exposed; split-origin DNS/TLS is optional embedding infrastructure.
2026-08-24 — 9Router joins the managed apps (one-click install/update/uninstall) (DONE)
Third managed app: 9Router (decolua/9router), the Docker-only AI gateway already serving
9-router.rahmanef.com from host port 20128. Unlike Hermes/OpenClaw it ships no CLI, so the
adapter contract is spoken by scripts/managed-app-9router — a repo-owned wrapper whose
verbs map onto Docker (--version reads the image's OCI version label, check --json
relays the app's own /api/version self-check, update --yes pulls latest and recreates
the container with the ~/.9router data mount intact, uninstall --yes [--dry-run]
removes only the container). Two small seams were added to the definition for it:
healthPath (9Router answers /api/health, and the default /health 404s — which would
read as unhealthy forever) and commandProvesInstall: false (the wrapper exists on every
checkout, so its presence must not make an uninstalled 9Router read as "package" and lock
the Install button out). Everything else — install/update/rollback/uninstall jobs, backups,
the split-origin dashboard proxy, the Details panel — is the existing generic machinery;
9router.mso.example.com was added to the Traefik managed-apps file and the wildcard DNS
already covered it. The container itself was updated 0.5.50 → 0.5.55 the same day.
A point-in-time security audit combined Claude Fable 5 in Ultracode mode with an independent
dynamic/manual lane. Fable actually fan-out to 8 workstreams / 27 sub-agents (7 domain finders
plus 20 adversarial verifiers), while the second lane ran the security-relevant tests, route/auth
inventory, dependency audit, trust-boundary review, unauthenticated live probes and targeted race
reproducers. Full evidence and rejected candidates are in AUDIT-2026-08-24.md.
Three vulnerability classes survived verification. A nested deploy key named id_rsa was not
covered by the fixed $HOME credential denylist, and recursive ZIP could carry nested id_* /
*.pem; both are now basename-aware / force-excluded. More importantly, MCP OAuth/token and
device-approval JSON stores used atomic rename without serializing the enclosing read-modify-write
transaction. Stress proved single-use OAuth codes could be consumed twice, concurrent mints could
lose state, and successful token/device revocations could be overwritten by a simultaneous usage
touch. Security-store mutations now serialize in process and use one fail-closed cross-process
lock protocol shared with the operator device CLI; corrupt CLI store reads also fail closed. The
shared limiter no longer lets attacker-controlled pre-auth IP churn share eviction state with
authenticated token/owner-action buckets; public and privileged pools are separately bounded.
Permanent regressions pin concurrency, kill-switch integrity, nested private-key classification, ZIP filtering, corrupt-store handling and limiter churn. Pre/post stress evidence is kept in the audit rather than this running log. Release verification and live post-ship probes are required before this entry is considered shipped.
2026-08-24 — one-line install now ends in terminal onboarding + reviewed skill market (DONE)
The one-line installer previously did the build/service work but stopped at a block of
printed next steps. It created ~/.local/bin/mso and merely warned when that directory was
not on the current PATH; because curl | bash runs in a child process, exporting PATH there
cannot make mso -h available in the parent shell. It was also intentionally
non-interactive, so a successful fresh install felt like "nothing happened" once the build
finished.
Fresh service installs now create the user launcher plus a guarded /usr/local/bin/mso
symlink (only when the name is free or already points into this install), persist an
idempotent ~/.local/bin fallback in the normal shell profile, and assert that mso is
resolvable before finishing. Uninstall removes only launchers that still point into the
MSO checkout. The bootstrap remains pipe-safe, but a fresh interactive install opens
/dev/tty after health succeeds and launches new mso onboard; existing installs do not
repeat it unless --onboard is passed, --no-onboard suppresses it, and no-TTY/cloud-init
installs never block. -y runs safe minimal onboarding: it leaves external AI accounts,
response style, optional managed apps and community skills untouched.
mso onboard is reusable and configures the existing surfaces rather than inventing a
second settings store. It can connect Alfa through OpenAI ChatGPT/Codex device OAuth, or
securely read an Anthropic/OpenAI Platform/OpenRouter/Google/Groq/xAI/DeepSeek/Mistral API
key from the controlling terminal with echo disabled and post it via stdin rather than
process argv. It exposes Normal/Caveman/Ponytail response presets, optionally runs the real
Hermes/OpenClaw managed-app install jobs while streaming their transcripts, then presents
the reviewed skill market. Managed-app provider state remains explicitly separate from
Alfa credentials. Settings' old "Codex is chat-only" copy was removed because the current
Codex Responses adapter forwards Alfa tools.
The new curated skill market is intentionally different from general skill discovery.
mso skills available/info/install/remove installs exact committed, SHA-256-checked
SKILL.md files into the explicit operator-trust root ~/.mso/skills, recording
.mso-market.json provenance. -y confirms only the entries the operator selected; it
will not overwrite a modified/local skill without an additional explicit --force, and
removal refuses directories it did not install. Initial reviewed entries are pinned
Ponytail 4.9.0, Caveman 1.0.2, and an MSO-authored safe RTK wrapper. RTK deliberately does
not copy the current upstream auto-setup instructions: it uses RTK only when the binary is
already installed and never runs an unpinned remote installer, edits shell profiles or
enables global hooks without a separate explicit system-change request. Caveman/Ponytail
remain available independently as Alfa response presets; selecting a preset never silently
installs the full skill.
README, docs/INSTALL.md, generated docs/CLI.md, skills/README.md, and the public
/install page now describe this same lifecycle. Regression tests pin installer TTY/PATH
behaviour, public install copy, credential transport, safe -y, skill hash/provenance,
modified-skill overwrite refusal, and unmanaged-skill deletion refusal. Full verification:
185 test files / 1,585 tests passed (1 expected fail, 4 skipped), typecheck green, lint has
the one pre-existing max-lines warning and zero errors, docs checker reports 38 Markdown
files / 28 MCP tools / 21 slices / 10 AppShell feature dirs, 9 official skills are valid,
value cycles remain zero, contrast has zero AA failures, and the high/critical dependency
audit is clean.
2026-08-24 — documentation authority + ChatGPT MCP guide (DONE)
The documentation set was audited against current source and the deployed/public MCP
contract instead of patching isolated stale paragraphs. docs/README.md now classifies the
repository into current reference, generated/current records, historical point-in-time
plans/audits, and marketing collateral; docs/ARCHITECTURE.md is current again, while the
June audit and old shell/BYOK plans keep their original evidence behind explicit historical
banners. The long-standing PROGRESS.md header that incorrectly said Architecture was no
longer maintained was corrected without rewriting old entries.
MCP/ChatGPT documentation is now split by responsibility. docs/MCP.md remains the deep
protocol/security/discovery/workflow reference, and new docs/CHATGPT-PLUGIN.md is the
operator-facing custom MCP app guide with architecture, OAuth sequence, scope/tool,
tool-snapshot refresh, workflow-id, ChatGPT-file-upload and credential-boundary Mermaid
diagrams. At that 2026-08-24 snapshot it recorded server 1.6.0, toolset 2026.08.21.1,
28 tools (15 read / 10 write / 3 exec); those counts are historical, while Settings → MCP and
GET /mcp are the current authority. The guide also documents the authorization-code-only PKCE flow and
90-day bearer reauthorization boundary, and clearly separates MSO MCP OAuth from Alfa's
OpenAI Codex/ChatGPT-subscription OAuth. Current OpenAI Developer Mode availability and
frozen-action behaviour are labeled as an external dated dependency rather than an MSO
promise.
Managed-app, Hermes, OpenClaw, install, security, troubleshooting, FAQ, model-provider and
slice references were brought to current behaviour: no runtime /features scraping or
workspace modes, no supported same-origin vendor dashboard, restore/update/install jobs are
documented, Camoufox replaces the retired Playwright daemon, current persistent profile
paths are explicit, and deploy/recovery uses bun run ship / mso update run --rebuild
instead of stale manual production build instructions. Official operational skills were
updated where their managed-app/deploy capability maps had drifted.
A new committed scripts/check-docs.mjs now makes common drift a quality-gate failure. It
checks relative Markdown links and generated CLI freshness, requires every docs/*.md to
be classified, validates current MCP version/scope/tool names in the three contract
docs, and validates actual slice/AppShell feature names/counts. package.json and
scripts/gates.sh both run it. Verification: full bun run verify exit 0; 181 test files
passed (1 skipped), 1573 tests passed (1 expected fail, 4 skipped); 0 value cycles; docs
checker reports 38 Markdown files / 28 MCP tools / 21 slices / 10 AppShell feature dirs;
9 official skills valid; WCAG palette audit 0 AA failures; dependency audit clean at
high/critical. One pre-existing max-lines lint warning remains in lib/mcp/dispatch.test.ts.
2026-08-21 — opt-in project MCP/function capabilities; stock MSO unchanged (DONE)
Project-specific automation no longer requires a business-specific feature in MSO. A
validated project may opt in with .mcp.json (presence only; contents/credentials are
never exposed) and .mso/functions.json (versioned public schemas + fixed argv). The
public MCP catalog stays stable: project_capabilities discovers one project's declared
surface and project_function_call executes one declared function at exec scope.
Function names are data, not dynamic MCP tool names, so switching projects does not alter
the model tool prefix or invalidate the prompt cache. Caller input is JSON stdin to
spawn(argv) — never shell interpolation — and child processes inherit the existing
credential-scrubbed environment. No manifest means no extra capability.
The same opt-in rule now applies to public machine ingress.
OS_PROJECT_INGRESS_ROUTES defaults to empty; when explicitly configured it permits at
most eight exact POST paths on known managed-app hosts, targets loopback HTTP only, and
requires HMAC-V2-shaped JSON traffic before the app-host CSRF gate. The loopback app still
verifies the real secret. There is no project/product name or webhook path compiled into
MSO. Tests pin both sides: stock MSO remains closed, malformed/off-box/wildcard routes fail
closed, .mso symlinks are ignored, project commands cannot interpolate caller strings
into a shell, and project function execution remains exec-only. Toolset advances to
1.6.0 / 2026.08.28.1: 31 tools (16 read, 10 write, 5 exec).
2026-08-20 — lossless continuation and exact-id project resolution (DONE)
The final fail-closed review found six remaining items. Five were continuation bugs of the same species — a cursor that described where a scan stopped instead of being a position you could resume from.
Hidden rootHint still resolved. validateRootHint checked the final entry for
symlink, shape, uid and credentials but never for a dot-prefixed component, so supplying
<authorized-root>/.hidden as the root resolved a project underneath it by exact name
while enumeration refused the same tree. The hidden check is now measured relative to the
authorized root: the root's own path may contain dot components (a checkout under
~/.claude/worktrees does), but nothing below it may.
maxRoots could not advance, ever. listProjectDirs() rebuilt the same capped
projectContainers() on every call, so a 13th configured root stayed pending no matter how
many times a client followed the cursor. Root identity is now an index into the uncapped
configured list, authorizedRoots(startIndex) slides that window forward, and the
continuation carries the index of the first root the scan could not honour.
maxProjects and maxProjectSkills lost entries. Both derived a readdir position from
sorted accepted rows and a global result count — arithmetic that cannot be truthful, and
which emitted entriesConsumed=400 for a root holding 250 dirents. Both walks are now a
single streaming pass: each dirent is validated as it arrives, every cap is checked
before the entry is touched, and the recorded position advances only after the entry is
fully handled. The skill cursor separately records roots that finished cleanly, projects
whose every root finished cleanly, and the exact position inside the one interrupted root —
a partially consumed project is re-listed and resumed rather than marked done.
Deadlines skipped unprocessed entries. Both scanners read every name, sorted, then validated; a deadline expiring during validation left the position past names nothing had looked at. Same streaming fix — the cursor cannot outrun the work.
Exact project ids were unusable through workflow_start. resolveProjectHint had no
root-qualified-id branch, so <rootId>/<name> fell through to fuzzy matching and, with two
same-named projects, returned the wrong one. An exact <32-hex>/<name> is now parsed and
resolved before alias, package or fuzzy; the rootId maps to exactly one container across
every configured root; an unknown rootId is refused rather than guessed.
The colliding pair from the previous review (/tmp/mso-root-50323 and
/tmp/mso-root-125549, both 51e156ef at 8 hex) is now an end-to-end regression:
projects_list, skills_list, skills_read, skills_search and workflow_start each
return the second project when handed the second id. Continuation reproducers drain
13 roots, 2×250 projects, a 437-entry root and a 150+160-skill pair to completion and
assert no row is dropped or repeated. Note that there are deliberately two paginations —
hasMore/nextOffset within one scan, scan.continuation.cursor across scans — and the
docs now say so, because conflating them looks exactly like data loss.
The positive suites are unchanged and green: all-agents-all-tools, the exec/read/write
ladder, image generation removed everywhere, fs_upload_file with regional ChatGPT import,
and auth/OAuth untouched. project-identity.ts, project-authorized-roots.ts and
catalog-cursor.ts split the work so every file stays under 200 lines and the value-cycle
count stays at zero. The MCP server/toolset advance to 1.5.3 / 2026.08.20.6; the catalog
stays at 26 tools (14 read, 10 write, 2 exec).
2026-08-20 — one validator, dirent-counted budgets, resumable caps (DONE)
A second fail-closed re-review of the discovery hardening found six things still open. Five of them share a shape: a rule enforced in one code path and assumed everywhere else.
UID and symlink rules existed only in the walk. listProjectDirs() rejected a
project owned by another uid, but resolveProjectHint's exact-name, alias and path
strategies did not — so workflow_start could resolve, and read metadata from, a project
projects_list correctly refused to show. rootHint went through resolveReadable(),
which canonicalizes and therefore follows a symlinked root, and a path hint accepted
hidden or symlink-reached directories inside it. There is now ONE validator
(lib/host/project-candidate.ts) and every strategy calls it: hidden component, symlinked
component (target legal or not), container/authorized-root escape, credential path, uid
ownership — ownership before any metadata read. A path hint is checked component by
component from the container down, because canonicalizing first and validating afterwards
is precisely what let a symlinked intermediate through. rootHint is validated the same
way, and authorized against every configured read root rather than the scan-capped
subset, so naming a root neither widens the jail nor shrinks it.
readSkillFile was nofollow at the wrong path. It realpath'd the supplied path, saw a
basename of SKILL.md, and opened the target with O_NOFOLLOW — enforcing the promise
against a path the caller never gave us. A SKILL.md -> other/SKILL.md symlink sailed
through. The supplied path is now opened directly, so any symlink at that component fails
with ELOOP; parent containment is a separate check, kept separate so the final component
is never dragged back through realpath. A symlinked SKILL.md is no longer an untrusted
skill — it is not a skill, and it is dropped from the catalog.
Budgets counted the wrong thing. Both walks incremented their entry cap only for
accepted entries, so a container holding a million regular files still cost a million
iterations before the "400 entry" cap was reached — the cap bounded the result, not the
work. Every dirent now consumes budget, and the deadline is enforced through the
per-entry lstat/realpath/metadata work as well as the dirent loop. The overall
300-project-skill cap moved inside the candidate loop; checking it only before each root
let one root carry the total from just under 300 to nearly 500.
Caps were reported but not continuable. A truncated scan named its reason and stopped.
Every cap now emits scan.continuation: pending roots, per-root cursors, and an opaque
cursor to pass back to projects_list / skills_list to resume where the walk stopped.
Cursors are positional in readdir order and say so — name-ordered resume would require
visiting every dirent, which is the unbounded walk the cap exists to prevent. Ordinary
paging within one scan gained hasMore/nextOffset.
Eight hex characters is not a unique id. rootId was 32 bits of sha256, and a probe
found a genuine collision: /tmp/mso-root-50323 and /tmp/mso-root-125549 both hash to
51e156ef, which would have merged two roots' same-named projects back into one row —
the exact bug root-qualified ids were introduced to fix. It is 128 bits now, both sides
share one shortId rather than each computing its own, and nothing dedupes on the hash at
all: the internal key is the full canonical path, so even a collision cannot merge two
containers. The collision pair is a regression fixture.
Regressions cover each: exact/path/alias uid mismatch, symlinked and hidden rootHint
and path hints, SKILL.md -> SKILL.md, a root of non-directory entries exhausting the
cap, maxProjectSkills overshoot, resumable continuation for entry and project caps, and
the deliberate root-id collision. The positive suites are unchanged and green:
all-agents-all-tools, the exec/read/write ladder, image generation removed everywhere, and
fs_upload_file with regional ChatGPT import. project-candidate.ts, project-cursor.ts,
project-list.ts and project-scan-types.ts split the work so every file stays under 200
lines. The MCP server/toolset advance to 1.5.2 / 2026.08.20.5; the catalog stays at
26 tools (14 read, 10 write, 2 exec).
2026-08-20 — discovery containment, honest bounds and unique ids (DONE)
A fail-closed review of the discovery release found three things worth blocking on, and all three came from the same habit: treating "we checked the happy path" as containment.
A symlinked projects/ escaped the read jail. <root>/projects was accepted on a
plain realpath, so with OS_FS_READ_ROOTS=/safe and /safe/projects -> /outside, the
enumerator walked /outside and project-skill discovery could mark same-uid skills there
local — instructions handed to a model from outside the jail entirely. Each configured
root is now canonicalized ONCE into an authorized root; a derived container must be a
REAL non-symlink directory whose realpath stays inside that same root. A symlinked
projects/ is refused even when its target is currently legal, because accepting it is a
TOCTOU bet. Every project candidate is re-checked too: non-hidden, non-symlink, realpath
still inside its exact container AND an authorized root, and owned by MSO's uid — checked
BEFORE any metadata read, so a directory another user controls never reaches the readers.
The advertised limits bounded nothing. readdir materialized a whole container
before slicing, global skill roots had no entry budget at all, and package.json,
SKILL.md and packed-refs were read in full and sliced afterwards — so one read-scope
projects_list on an attacker-influenced tree was a memory-exhaustion primitive. Both
walks now use opendir and stop at the cap, global skill roots got the budget they were
missing, and every metadata read goes through one O_NOFOLLOW reader that checks the cap
against fstat before any bytes move. Each walk also carries a 4-second wall clock.
Truncation lied. projectRoots() returned early after 12 roots and each container was
silently sliced to 400 entries, yet only the separate 400-project condition set
truncated. A caller could be told the scan was complete while configured containers were
never opened. Every discovery response now carries a scan report: truncated:false means
"this is all of it", and any cap sets truncated:true with a named reason
(maxRoots, maxEntriesPerRoot:<path>, maxProjects, maxProjectSkills, deadline)
plus scannedRoots, skippedRoots and a count of rejected entries. workflow_start
carries discovery.complete and adds a [Discovery] partial scan trace line, and the
tool descriptions tell the client not to conclude something is absent from a truncated
scan.
Ids were not unique. A project skill was <project>/<name>, deduped by that string,
so two configured roots each holding a widget collapsed into one row and a whole
project's skills were unreachable. Identity is now root-qualified: a project is
<rootId>/<name> and its skills <rootId>/<project>/<name>, where rootId is a short
sha256 of the canonical container path. The derived projects/ container gets its own id
for the same reason, so ~/widget and ~/projects/widget no longer collide. skills_read
takes the exact id and REFUSES an ambiguous bare name with the candidate list rather than
returning one project's instructions under another's name; skills_list's project filter
accepts an exact projectId, a path or a bare name, reporting ambiguousProjects when a
bare name spans roots.
rootHint was half-wired. Exact names probed the named root, but package and fuzzy
resolution walked the global capped list and filtered — so a readable root absent from
that list could never match by package or fuzzily. All three strategies now run inside the
named root, and a path hint may not leave it. The exact-name probe also refuses a symlink
(target legal or not) and a hidden directory, matching what enumeration excludes.
Regressions cover every one of these: escaping and inside-jail symlinked containers,
symlinked project entries, 13+ configured roots, 401+ entries in one container, duplicate
project basenames across roots, oversized package.json/SKILL.md, uid mismatch,
rootHint package and fuzzy resolution, and truthful truncation. The positive suites are
unchanged and still green: all-agents-all-tools, the exec/read/write scope ladder, image
generation removed everywhere, and fs_upload_file with regional ChatGPT import.
lib/host/project-containers.ts, project-roots.ts, bounded-read.ts and
lib/skills/catalog-scan.ts split the work so every file is back under 200 lines. The MCP
server/toolset advance to 1.5.1 / 2026.08.20.4; the catalog stays at 26 tools
(14 read, 10 write, 2 exec).
2026-08-20 — global project/skill discovery, and image generation removed (DONE)
Capabilities are global now, and the docs say so. Two invisible scopings shipped
together and were both wrong for the same reason: MSO answered "what projects exist"
and "what skills exist" from ~/projects and the global skill roots alone. An owner
who configured three read roots got one of them, and an agent working in project X
could not see X's own SKILL.md. Nobody decided either; they were defaults nobody
revisited. A capability that silently covers a subset of what the owner configured is
worse than one that refuses.
Three new read MCP tools. projects_list enumerates project directories across
every configured container — each OS_FS_READ_ROOTS entry plus its projects/ child,
deduped by realpath, in configured order — with name, path, container root, package
name/version and Git branch/head read straight off .git with no subprocess. Hidden
dirs, symlinks and credential paths are excluded; the scan is bounded (12 containers,
400 entries each, 400 projects) and paginated (default 50, max 200). / is never a
container. resolveProjectHint searches the same containers, exact-before-fuzzy: an
absolute/~ path wins outright, then an exact name or alias probed container by
container, then one bounded scan scoring exact package names above substrings — so an
exact name in the second container beats a substring hit in the first.
skills_list and skills_read merge the global roots with the per-project roots
of every project: .mso/skills, .claude/skills, .hermes/skills, .agents/skills,
.codex/skills. Skills are now addressed by a catalog id: a global skill by bare
name, a project skill as <project>/<name>. Two projects may both ship deploy and
neither can displace an operator or official skill — the collision is impossible rather
than resolved. skills_read takes the exact id and does not fuzzy-resolve into a
project namespace. Project trust is EARNED, not inherited from the path: local only
after realpath containment inside the project, ownership by MSO's uid, and a regular
non-symlink SKILL.md. Everything else stays untrusted — metadata visible,
instructions withheld until the operator reviews and promotes it into ~/.mso/skills.
The generic HOME agent roots keep their untrusted behaviour unchanged. workflow_start
and skills_search search the unified catalog and each skill hit carries its project.
Bounds: 60 projects, 100 skills per root, 300 project skills, 24,000 characters per read.
skills_list/skills_read therefore exist on BOTH surfaces now, and their old
ALFA_ONLY parity exemption ("stays off a bearer-reached surface") is gone. That was
the right call for a fuzzy name-resolving reader; it is not for one that takes an exact
catalog id, returns instructions only for trusted tiers, and still opens nothing but a
realpath'd file named SKILL.md.
The global-tools invariant is now pinned, not just described. Alfa already sent
every tool on every turn; MCP already showed an exec token everything. Neither had a
test that would fail if someone added a per-project filter. lib/mcp/global-tools.test.ts
and a new block in registry.test.ts hold both: the exec catalog equals TOOLS exactly,
read/write are strict prefixes by tier and nothing else, workflow_id is optional on
every operational tool, HOST_AI_TOOLS is the same whole-catalog object every turn, and
registry.ts exports nothing that could narrow it. The read/write opt-down and the
exec consent default are unchanged and covered — the ladder is the security boundary;
which tools exist is not.
Image generation is removed end-to-end. image_generation_status, image_generate,
lib/image-generation/, OS_IMAGE_MODEL, OS_IMAGE_OUTPUT_ROOT, the image.generate
audit action and workflow-memory entries, and the Codex provider-side image_generation
built-in are all gone. A GPT client already carries its own image generation; offering a
second tool for the same job made the model choose between them, usually wrong, and the
MSO one billed a separate API key. OS_CODEX_BUILTIN_TOOLS now defaults to EMPTY and no
longer accepts image_generation — naming it explicitly is dropped, not honoured, and a
test pins that. fs_upload_file is deliberately preserved, regional ChatGPT file
import and openai/fileParams binding intact: generating elsewhere and importing here is
the whole remaining flow. No tool description tells a client to prefer a native or
provider image tool, and a test greps for that wording.
lib/mcp/tools.ts shed apps_power/browser_power into tools-power.ts and the new
tools live in tools-discovery.ts, so every file is back under the 200-line ceiling.
lib/host/project-meta.ts and project-roots.ts split the symlink-refusing readers from
the container enumeration. The MCP server/toolset advanced to 1.5.0 / 2026.08.20.3,
with 26 tools (14 read, 10 write, 2 exec). See the entry above for the containment,
bounds and id-uniqueness fixes that followed the review of this release.
2026-08-20 — provider-backed MCP image generation (SUPERSEDED — removed same day)
MCP now exposes image_generation_status (read) and image_generate (exec).
Generation uses the official OpenAI Images API rather than the prior procedural
icon scripts or the internal unofficial Codex backend. One billed call creates one
lossless PNG sandbox master plus a prompt-free 0600 provenance sidecar containing
provider/model/request id, prompt and byte hashes, dimensions, alpha status and
eligibility findings. The raw prompt is excluded from activity, audit and learned
workflow memory. The output root is write-jailed (OS_IMAGE_OUTPUT_ROOT, default
~/generated-images), generated filenames are unique, temporary previews remain
authenticated/expiring, and image calls are limited to 5/min. The MCP server/toolset
advance to 1.4.0 / 2026.08.20.1, with 24 tools.
2026-08-20 — image generation and full-access defaults (image half SUPERSEDED)
Fresh MSO installs now expose Codex provider-side image_generation when
OS_CODEX_BUILTIN_TOOLS is absent, matching the owner's expected assistant capability.
An explicit empty value still disables every provider built-in, and an explicit list
replaces the default through the existing allowlist. Regression tests cover the default,
the opt-out, and unknown-tool filtering.
MCP now defaults its ceiling to exec, and the OAuth consent form preselects the highest
tier that ceiling permits, so “Allow” grants full access without an extra radio change on
the owner's single-user deployment. OS_MCP_MAX_SCOPE=read|write still opts the whole
server down, malformed explicit values fail closed to write, the form still shows the
full-shell warning, and the server action keeps absent/unknown submitted scopes at read.
2026-08-19 — isolated parallel workflows and a skill-flow factory (DONE)
The first bootstrap release still had one unsafe fallback: active workflow memory was
keyed only by MCP actor, so a second conversation using the same token silently replaced
the first, and workflow_finish could omit its id and close whichever run happened to
be active. A real reconnect had already produced a mismatched learned recipe this way.
Workflow memory is now a v2 multi-run store. Every workflow_start receives a unique
id, and multiple conversations may run safely in parallel on the same MCP token. Both
workflow_finish and the new workflow_cancel require that exact id; cancel removes
only the interrupted run without creating a recipe. Every operational schema carries an
optional workflow_id: exact-id calls join that recipe, missing-id calls remain
standalone, and unknown ids are refused before execution. The loader migrates a live v1
actor workflow without dropping it, serializes concurrent cold loads, prunes stale runs,
and bounds each actor to 20 active workflows. Workflow cancel is audited, Activity
renders cancelled runs explicitly, and migration/parallel/wrong-id cases have regression
tests. The reusable best path is also compressed to at most 24 completed steps while the full redacted evidence remains available, preventing a long audit from becoming a 300-call recommendation. The MCP server/toolset advance to 1.3.0 / 2026.08.19.2, with 22 tools.
Skill authoring is now repeatable rather than copy-paste. bun run skill:new renders
templates/mso-skill-flow/SKILL.md.template into a new official skill and refuses an
overwrite. The template standardizes selection boundaries, bounded-vs-terminal routing,
visible operational trace, done conditions, rollback, approvals and recipe redaction.
bun run skill:check validates every official skill's directory/name, description,
risk, policy, H1, unresolved placeholders and 200-line ceiling, and is part of the main
check gate. The new trusted mso-skill-authoring playbook explains the flow.
OAuth consent now also forces a visible top-level callback. The previous success path
called Next's redirect() from a Server Action nested inside a client form action. The
authorization callback could run through the action transport—ChatGPT exchanged the code
and created an exec token—while the MSO tab remained on “Connecting…”. The server action
now returns only its already-validated, PKCE-bound callback URL, and the client performs
window.location.replace(). This preserves the same-origin approval boundary while making
the browser visibly leave MSO for ChatGPT; non-HTTPS non-loopback targets are refused again
at the browser boundary.
2026-08-19 — MCP one-call bootstrap, visible workflows and faster repository work (DONE)
A refreshed ChatGPT connection proved the server really exposed all 21 MCP tools, but
it also made the remaining orchestration cost visible. The client still had to search
skills and start a workflow as separate calls; os-vps no longer matched the renamed
mso directory; MCP activity was a flat list even though the backend already stored a
workflowId; tool descriptions and schemas could change without an operator-visible
signature; and the systemd environment handed exec_run no ~/.bun/bin, so every Bun
command first failed or required an absolute path. The live baseline also returned no
toolset metadata from GET /mcp, and fs_search("os-vps") returned an empty result.
This release keeps the public catalog at 21 stable names and makes the existing
workflow_start the one bootstrap call for multi-step work. It now starts the
actor-scoped workflow, searches trusted skills/tools/recipes, resolves the project,
returns package and Git context, reports the scoped toolset version/hash/count, and
emits the high-level [MSO], [Project], and [Plan] trace. skills_search remains the
standalone capability-research route; clients are explicitly told not to call it
immediately before workflow_start for the same task. Initialize instructions now
prefer bounded tools for one or two direct operations and one narrow terminal batch for
repository-wide search, Git, tests, builds, or three-plus related checks. They request
feature badges such as Skills, Files, Terminal, Git, Build, Verify and Screenshot—not
private chain-of-thought.
Project resolution now has safe aliases for os-vps, Manef Shell OS and MSO, with an
immediate exact-name/alias return instead of parsing every project package. Package and
Git metadata refuse symlinks. fs_read returns UTF-8 bytes plus SHA-256, and
fs_write.expected_sha256 provides an optimistic stale-overwrite guard. Spawned shells
retain secret scrubbing but prepend the owner's ~/.local/bin and ~/.bun/bin, so Bun
and owner-installed CLIs work without rediscovery after restart.
The MCP protocol, public /mcp descriptor and Settings API now expose server version
1.2.0 plus a schema-derived toolset signature (2026.08.19.1). Settings → MCP displays
that signature and records a browser-local acknowledgement after ChatGPT is refreshed;
a later change becomes a visible stale-snapshot warning. Assistant → MCP now groups
activity by workflow intent/project, collapses start/completion pairs, aggregates steps
and duration, and renders feature-specific icons. Only a completed workflow_finish
marks a workflow Verified; standalone calls are merely Completed. Workflow intent and
project are redacted/truncated before persistence.
Three official operational skills were added: mso-repo-work, mso-deploy, and
mso-service-debug. The MCP and external-integration documentation at that checkpoint treated the 21-tool
runtime signature as the cross-client contract and records that the gateway still maps
15 actions. New public repo_* or job_* names were deliberately not added in this
release: keeping the action catalog stable lets the refreshed connection benefit
immediately, while scoped terminal batching and the existing release/job infrastructure
cover the current bottleneck without another catalog expansion.
Verification before ship: targeted bootstrap, alias, symlink, guarded-write, toolset,
activity and dispatch tests passed; bun run verify passed typecheck and lint, 144 test
files / 1,351 tests, the coverage thresholds (22.51% statements, 20.80% branches,
16.67% functions, 23.02% lines), 765-file cycle scan with zero value cycles, both light
and dark contrast audits with zero AA failures, and a clean high/critical dependency
audit. The committed pre-push gate performs the out-of-tree production build again
before any push, and bun run ship preserves the required commit → changelog → push →
build → restart order.
The first live ship exposed one more orchestration fact that tests could not simulate:
exec_run is a child of mso.service, and the service manager terminates the whole
cgroup when that process is replaced. The new build came up healthy, but the parent
release command died before it could write its exit file or perform its own chunk
check—nohup did not move it to a different cgroup. ship.sh now detects that
execution context after the gated push and hands rebuild-only
build/restart/verification to the existing owner transient mso-self-update.service.
The handoff has no request-derived shell payload, reuses the same fixed script and
one-hour bound as Settings self-update, writes ~/.mso/self-update.log, and is
regression-tested with a fake systemd-run argv capture. SSH releases remain
synchronous; MCP releases must poll the returned unit/log until UPDATE OK before
declaring success.
2026-08-19 — v0.2.1: self-update stopped assuming passwordless sudo (DONE)
A real 0.2.0 installation exposed the gap: Settings found the incoming commits, but
pressing Update failed immediately with sudo: a password is required. Nothing had
been pulled or built, so the running copy stayed safe; the button was nevertheless
unusable on an ordinary VPS account. The installer never created a passwordless
sudo rule — correctly — while startUpdate() had silently required one.
The updater is non-root now. startUpdate() launches an owner-scoped transient unit
with systemd-run --user, which gives the build its own cgroup so it survives
replacing mso.service. At the end, the script reads the service's MainPID, proves
that PID belongs to the same uid as the updater, sends it SIGTERM, and waits for a
new active PID. The installed system unit's existing Restart=always starts the
fresh build; no sudo credential or broad sudoers exception is needed.
The preflight also refuses clearly when the per-user systemd manager is unavailable,
when mso.service is missing, or when the service belongs to another user. The
installer now starts [email protected] after enabling linger and verifies that the
user bus answers, so a fresh install can use the update button immediately. Argument
construction has regression tests that explicitly reject sudo and a root-capable
User= property. Typecheck, lint, the architecture/contrast checks, dependency audit,
and the full 1,336-test coverage suite passed before release; the final rebuild-only
path was exercised against the live service and ended in UPDATE OK.
Existing 0.2.0 installations need one interactive installer run to receive this fix, because the broken updater cannot bootstrap its own replacement. After that one-time migration, future Settings updates run without a sudo prompt.
2026-08-17 (audit) — a codebase pass: what was duplicated, what had drifted, what was undefended (DONE)
Not a UI pass. Scanned for dead exports, parallel implementations, unguarded contracts and untested risk, then fixed what was real. What the scan found and what it did NOT find are both worth recording.
Duplication that was also a bug.
- Six copies of "download this URL", disagreeing on the two details that decide
whether the file arrives. Two clicked a DETACHED anchor — Firefox ignores
downloadon one, so it navigates instead of saving, and one of the two was the Settings → Backup export. Three disagreed on when to revoke the blob (0 ms / 2000 ms / never; same-tick revocation lands a 0-byte file in Firefox and Safari). Now onesaveAs()in appshell, with both rules and a test that asserts the anchor was in the document AT THE MOMENT of the click. - Three copies of POSIX path math. Files'
joinPathdid not strip a trailing slash, the Code editor's did, Preview's sibling lookup carried a third regex. These strings become thepath=of an/api/v1/fsrequest, so/a//bis a different path to a host that resolves it literally. Onelib/path.tsnow —lib/, not appshell, because the framework may not depend on mso's lib and this is the same universal category ascn. - Files' icon + colour tables had drifted from Preview's format table: a
.heicdrew a generic grey icon and a.m4van uncoloured one, because the local sets predated the viewer's. Both readkindForNamenow; the dead sets are gone.
A test-runner bug that was hiding, not helping. vitest.config.mts listed
"@": root BEFORE "@/features", and Vite tries aliases in insertion order — so
@/features/os-shell resolved to <root>/features/os-shell, which does not exist.
No test had happened to pull a slice barrel into its graph, so it read as green
until one did. tsconfig had it right the whole time; only the runner disagreed.
Contracts nothing was checking, now checked.
media-viewer/lib/kinds.ts↔lib/host/fs.ts: every extension Preview points an element at must have a real Content-Type, or the element errors and the operator is told their browser cannot decode a file it decodes fine. The same test asserts the map NEVER grows an executable document type —text/htmlthere would make any host file an active document on the cockpit's origin..env.example↔process.env: CLAUDE.md carried this as a chore, and the chore had slipped.OS_CODEX_BUILTIN_TOOLS— which turns on provider-run tools that BILL to the owner's account — was readable by the code and documented nowhere. Now a test, with an exemption list that is itself checked for staleness (it caught two entries for vars nothing reads any more).
A real hole in the credential denylist. It blocked shell HISTORY but not the
shell RC and PROFILE files, and ~/.bashrc on this box holds eight
export …_TOKEN= lines — put there by tooling that says "add this to your shell
profile". fs/read handed them over, and the assistant's read-tools run with no
approval gate. Blocked now (.bashrc, .zshrc, .profile, fish config, …),
verified against the running service: .bashrc → 400 "credential/sensitive files
is blocked", .gitconfig and .vimrc still readable. OS_FS_ALLOW_SENSITIVE=1 is
still the escape hatch, and a terminal window is right there.
The riskiest route had no test. /api/v1/sys/update replaces the code the whole
cockpit runs. It now has six: signed-out gets nothing on either verb AND the host is
never touched, ?check=0 really skips the network round trip, rebuildOnly is only
honoured when it is exactly true (a hand-rolled client sending "yes" must not
mean "rebuild"), a refusal is its sentence and a 400 rather than a 500, and BOTH the
start and the refusal reach the audit log while a read reaches nothing.
Also: the update status read its log file twice per poll (every 3 s during a build); coverage thresholds ratcheted 19/18/14/19 → 20/18.5/15/20.5, a hair under the measured 20.47/19.2/15.15/20.86, per the rule written above them.
Deliberately not done, so the next pass does not re-derive it:
verifyAuth(req)discards its argument — it is a one-line wrapper overrequireSession(), and the parameter invites the reading that the request is checked (it is not;proxy.tsowns origin). Removing it is ~40 mechanical route edits, and another session was pushing to this repo the same hour. Worth doing solo, not worth a collision.- ~180 "unused" exports are mostly types re-exported as the appshell framework's
public surface, or consumed structurally. Only ONE module was genuinely dead
(
components/ui/segmented.tsx) — and it was a false positive: four slices import it under a name the scan's regex missed. Left alone. - Preview's sample gallery (7 files) parallels the real viewer, but the public demo is its live consumer — mock data has no bytes to render, so those samples are the only thing the demo can show.
2026-08-17 — the deploy became a button, and Preview learned the rest of the disk (DONE)
Two PRs from the fork merged first (#2 user bus, #3 dashboard silence), then two
features on top. The audit gate had been failing on main before any of it —
GHSA-2v37-7h3g-55p8, nanoid <3.3.18 through postcss — so main was unpushable
without --no-verify; pinned via overrides, which is what the gate's own message
asks for.
Software update, in Settings → About. Prod is systemd with no webhook, so a
commit on main changed nothing anyone could see until someone with ssh rebuilt. Now
the panel reports what is on origin/main, lists the incoming commits, and runs the
deploy.
Three things about it are load-bearing:
- The work does not run in
mso.service. Replacing that service makes systemd kill its whole cgroup — a detached child included. It would die mid-next build, with.nextalready deleted and nothing to restart into.startUpdate()now hands the job to the owner's TRANSIENT user unit viasystemd-run --user; that separate cgroup survives while the script signals the same-uid service PID and letsRestart=alwaysbring MSO back. The original 0.2.0 implementation used a system transient unit throughsudo -n, which failed on normal password-protected sudo accounts and was replaced in 0.2.1. - It verifies out-of-tree BEFORE building in place.
scripts/ship.shis run by a person who is watching; this is run by an operator who pressed a button and walked away.scripts/verify-build.shproves the pulled HEAD compiles without touching the live.next, so a commit that does not build becomes a refusal instead of an outage. An in-place build cannot be undone — there is no old.nextto put back. - Nothing from the request reaches a shell. The only knob is a boolean; the ref
is hard-coded to
origin/main. Refusals (dirty checkout, already up to date, one already running) are computed in a pureblockingReason()so they happen before anything is touched, andsys.updateis a new audit action — this replaces the code the whole cockpit runs.
The panel's "Release notes and docs" drawer lists the incoming commits (from
git log HEAD..origin/main, because the CHANGELOG in this checkout is by definition
the old one — it arrives WITH the update it describes), then the shipped changelog,
then links to README/CHANGELOG/PROGRESS/CLI. mso update status|run|log is the same
surface from a shell.
Preview now covers the disk, not four formats. One table
(media-viewer/lib/kinds.ts) exported through the slice barrel and used by BOTH the
viewer and Files, so the two can no longer disagree about what a .heic is:
- image/video/audio grew the Windows + macOS defaults (heic/heif, tiff, jfif, m4v,
wmv, mpg, 3gp, opus, aac, wma…). The server MIME map grew to match — passive
types only;
text/htmlthere would make any host file an active document on the cockpit's origin, which is the same hazard the SVGsandboxheader already exists for. - text, Markdown, CSV/TSV and HTML render, and their bytes are FETCHED (Range-
capped at 512 KB) rather than framed. HTML goes into a
sandbox=""srcdocframe: no scripts, opaque origin, and therefore no relative assets — the price of not handing a host file the session's origin. - Documents and archives are
noneon purpose (docx/xlsx/pptx/pages/zip/dmg/exe…). A browser cannot render them, and a viewer that pretends otherwise shows a blank frame that reads as MSO being broken. They get a card that names the format and offers the download. - ← → through the folder, plus the arrow keys, on every previewable file. The
sibling list comes from one
fs.listof the parent, not from the payload, so a window opened by deep link or by the assistant pages exactly like one opened from the grid. - Files gained Preview in the context menu and Space as its shortcut (the
macOS Quick Look binding), because a
.mdor.csvdouble-click correctly goes to the editor, and reading it is a different verb from editing it. - Long-press opens that menu on a phone. Touch has no contextmenu event worth relying on (Chrome Android fires one, iOS Safari mostly does not), so on mobile the ENTIRE context menu — Preview, Rename, Download, Move to Trash — had never been reachable. 500 ms, 10 px drift cancels, and the click the finger-lift produces is swallowed so it neither opens the file underneath nor dismisses the menu it just opened. Its rows are 44 px on coarse pointers now, for the same reason.
Found while verifying, and fixed: the panel first reported the CHECKOUT's HEAD as
"running", which is only true until someone pulls without rebuilding. next.config
now bakes the commit into the bundle (NEXT_PUBLIC_COMMIT_SHA, which About already
had a row for and always showed as "not set"), the status carries buildSha +
pendingBuild, and "already up to date" is no longer returned when the running build
is older than the checkout — it offers the rebuild instead.
Verified live, not asserted. scripts/e2e/preview.mjs (bun run e2e:preview [width]) drives the real :4005 at 1280 and 390: every format above, paging by button
and by arrow key, and the update panel. It checks that the bytes ARRIVED —
naturalWidth > 0, readyState >= 1, the text inside the sandboxed frame — because
an element that exists proves nothing. It also asserts the fixture's <script> does
NOT run inside that frame. It provisions its own fixtures under
~/.cache/mso-e2e-preview and skips what it cannot make (no ffmpeg → no video). The
full self-update path was exercised end to end the same way: the checkout was moved a
commit back, the button pulled, verified out-of-tree, built, restarted, and the CSS
chunk check passed — 6 minutes, UPDATE OK.
2026-08-11 — shells to their 2026 specs, and a backup for the state that had none (DONE)
Five parallel packages on strictly disjoint file sets, each reviewed against its own diff. The reviewers caught two packages that reported themselves complete and were not — Windows had not actually resized Start search results, and the parity package had fixed half of the adapter bug. Both closed before the gates ran.
Windows 11 — learn.microsoft.com's icon table (updated 2026-08-05): 16px title bar / context menu / tray, 24px taskbar + search + all-apps, 32px Start pins, at 100% scale. We had 20px taskbar glyphs, 28px list rows, 40px pins. Title bar was 34px against Win11's 32, which rendered the 46px caption buttons as 46×34.
A measurement worth recording. Live it renders 42px bar / 35px buttons / 21px
icons — because --font-scale is 0.875 on this box. 42/0.875 = 48, 35/0.875 = 40,
21/0.875 = 24, exactly. Windows chrome is sized in rem and follows the a11y font
scale; iOS chrome is px and does not. rem is the better a11y behaviour, so this is
recorded rather than "fixed" — but the two shells answering the same setting
differently is a real inconsistency and the next person should know before they
match one to the other.
iOS 26 — the home screen is a fixed 6×4 grid, 24 icons per page, horizontal
paging, 4-slot dock. Ours was one vertical scroller with three hardcoded dots. Now
grid-rows-6 + overflow-hidden with pages derived from the app count. Verified in
a real browser: icon 60.00×60.00, six rows, scrollHeight − clientHeight === 0.
The plan for this was wrong and that is the lesson: it claimed there was no
pagination, when the DOM had always rendered "Go to page 1/2/3". The agent was told
to MEASURE before changing anything, which is the only reason the paging that
already worked survived.
Android — M3 Expressive replaced duration+easing with physics springs: spatial
(may overshoot) for movement, effects (must not) for colour/opacity, three speeds
each. CSS has no spring, so each token is a real spring sampled into linear(). Six
M3 tokens collapse to three curves — a spring's normalised shape depends only on its
damping ratio; stiffness only scales time, which the durations carry. Durations are
multiples of --shell-dur ON PURPOSE: the reduce-motion block collapses that to
1ms, and hard-coded ms would have silently opted every Android animation out of it.
The notification shade had been animating UPWARD against the pull-down that summons
it. Ceiling, written in the CSS: a linear() cannot be interrupted and re-targeted
mid-flight the way a real spring can.
Parity — apps_power exposed three of the four actions MANAGED_APP_ACTIONS
declares; it reads the constant now instead of retyping it. apps_list returned a
bare array over MCP against the route's {apps:[…]}. Underneath both, the real bug:
lib/os-api/http-adapter never unwrapped those envelopes AND never translated the
wire's six-value state into the running boolean the port promises — so Alfa said
"no managed applications", and after a successful start, "undefined: stopped".
Third drift at that seam this week (wrong URL in 7ed3ff5, then unwrapped-but-
untranslated, now the mapping); lib/os-api/http-adapter.test.ts is the first thing
pinning any of it.
Alfa rendered every failure as "Couldn't reach the assistant" — including a 429, which sent people back to Send, the one action guaranteed not to work while the window is open. Four branches now.
Backup — Playbooks, Agents, Automations, window layout and desktop icons were
localStorage-only: clearing site data destroyed them with no recovery path.
Settings → Backup exports every mso-owned key as one versioned JSON and imports it
back. Keys are chosen by prefix rule plus a small allowlist rather than a hardcoded
list that goes stale silently, and mso.device.id is denied on purpose — restoring
one machine's device identity onto another is not a backup.
Disclosed in the UI: mso:tweaks and mso:quicklinks also sync via /api/prefs,
where the server wins on initial load, so an import of those two is overwritten at
the next sign-in. The real fix POSTs prefs after a restore.
Gates: typecheck, lint, 1230 tests, coverage 19.7%, cycles clean, browser e2e green at 1280 and 390 against the deployed build.
2026-08-10 (parity) — three tool surfaces, one gate (DONE)
A 13-agent parity audit across Alfa (function calling), MCP (ChatGPT/Claude/Cursor)
and the CLI (bin/mso, how an external agent drives the box). 58 claims, 53
survived adversarial verification. 11 capabilities were parity 3-ways, 7 absences
were documented decisions, and the rest was drift — nobody decided it.
The headline was backwards from the guess. A remote ChatGPT connector had MORE
reach over this box than the owner's own in-browser assistant: MCP shipped
apps_logs / apps_power / browser_status / browser_power this morning and
Alfa had none of them — while Alfa's apps.list had been answering "no apps
installed" for months, because /api/v1/apps returns [] by construction and the
port's apps.start/apps.stop pointed at routes that do not exist.
Alfa now has all four (power tools park an approval card, which MCP has no
equivalent of), and lib/mcp/parity.test.ts is the gate: a capability must exist
in BOTH catalogs or be named with a reason, a stale exemption fails too, and a tool
classified mutate on one surface may not be read on the other. Unifying the two
catalogs was considered and rejected — they share zero names, descriptions or
handlers, so a shared registry would be an abstraction over two consumers that
legitimately differ. The defect was never duplication, it was silence.
Bugs the audit found in code shipped hours earlier:
dispatch.tsrecordedok: truefor anything that did not throw.runCommandREFUSES a destructive command by returning code 126 — so a blockedrm -rf /landed in the trail as a successfulexec.run,exec.blockedcould never be emitted over MCP, and every non-zero exit read as success. Live proof was in the log. Now mirrors the route line for line, withdetail: exit Nit never recorded.- MCP's token bucket is tool-blind, so a write-scope token holding no shell could restart a daemon 120×/min against the UI's 12. Each mutating tool now mirrors its route's limit on the SAME key, so they share one allowance.
POST /api/v1/camoufox/servicehad no rate limit at all — fine while a UI toggle was the only caller, not fine once a bearer could reach it.- The camoufox port adapter sent
{enabled}to a route reading{action}. Types missed it: the port's body isunknown.
Security, in things that were already live:
/api/skillsfollowed symlinks with no check, outside the fs jail and outside the credential denylist, so a symlinkedSKILL.mdserved its target from anywhere. Now the resolved path must still be namedSKILL.md. Containment could not be the rule — every~/.claude/skillsentry links intoclaude-skills/, deliberately not a scanned root.- Recalled memories were spliced into the SYSTEM prompt unframed, and
memory.rememberruns with no card — so any file Alfa read could propose a "fact" that then reappeared as system text in every later turn of every thread. Now framed as data.memory.forget(unbounded substring delete, no backup, no card) moved to the mutate catalog. audit.jsandimage-editor.shfell back to a device id committed in a public repo, andaudit.jsprinted it with instructions to APPROVE it — which turns the device allowlist into password-only for anyone who read the source.
~/.claude/skills was not a skills root, so the five /mso* documents that
describe how to drive mso were the one catalog mso could not see: 89 skills served,
zero of them mso*. Adding the root found nothing on its own — those entries are
symlinks and Dirent.isDirectory() is an lstat. 115 reachable now, all five among
them.
CLI: bin/mso.test.ts compared PATHS while promising method coverage, so five
routes had no verb (mapp power, mapp cancel, mapp pending, threads save,
skills <name>). Tightened to (method, path). mso build ran next build inside
mso.service's WorkingDirectory without restarting — the exact sequence CLAUDE.md
forbids — and now runs verify-build.sh. mso --base <remote> device approve
edited the LOCAL allowlist and reported success; it refuses a non-loopback base now.
Doc sweep: /mso-apps told an agent to drive the browser with verbs that never
existed (a prior commit rewrote only the left half of the cell, leaving the list
behind a # so pasting it is a silent no-op); /mso-list claimed to probe every
endpoint while probing 13 of ~36; CONTRACT.md's "there is no second list" was
falsified the day MCP shipped; fs.list advertised sizes that are always 0, so
Alfa would call every file empty; mso search was documented as searching file
CONTENTS while it matches directory names.
2026-08-10 (mcp, follow-up) — the trail the MCP tools were bypassing (DONE)
Shipping the MCP server, the security story told to the owner was "scope is the containment, revoke is the kill switch". Both true, both weak without the third thing — seeing what already went through — and that was missing.
audit() is called at the ROUTE layer for /api/v1. MCP tools call lib/host
DIRECTLY (deliberately: that is how they inherit the path bounds and the credential
denylist), so every fs.write / fs.delete / fs.move / fs.copy / fs.mkdir /
exec.run / camoufox.power that arrived over MCP was absent from
~/.mso/audit.log, the only forensic record there is.
The dispatcher records it now — one place, not per tool. McpTool.audit names the
action and which argument is the target; dispatch() writes it with
actor: mcp:<id> (the same id Settings and mso mcp list show, so a line maps back
to the revoke button) plus meta.via="mcp" and the acting scope. Failures too, with
the reason, so a blocked path is visible rather than silent.
A scope refusal writes mcp.denied. Nothing happened, which is exactly why it is
worth a line: a read connector repeatedly reaching for exec_run is what a
prompt-injected model looks like from the outside, and this is the only place that
signal exists. Reads stay unlogged — bounded, high-volume, same rule the routes
follow, and logging them would bury the lines that matter.
readAuditTail() had had NO reader outside its own test since it was written, so
the trail was unreadable without cat. Added GET /api/v1/sys/audit (session-gated,
prefix + actor filters), mso audit [n] [prefix], and a "Recent MCP activity" list
in Settings → MCP. Deliberately no MCP tool for any of it: the trail records what
every token did, and letting a token read it would let a compromised one check
whether it had been noticed.
Two tools added, tiered by blast radius rather than by which layer they land in:
apps_logs is READ (a daemon's journal changes nothing, so "why is hermes down?" no
longer costs a shell) and apps_power is WRITE, not exec (three verbs against known
units — restarting a daemon should not mean handing over the ability to run
anything). The catalog split at the 220-line ceiling along the same tiering:
tool-kit.ts (shape + arg helpers), tools-read.ts, tools.ts (write/exec +
assembly).
A bug this found in itself: running the suite after wiring the dispatcher but
before mocking audit put two real mcp.denied lines into the owner's live
~/.mso/audit.log at 08:49:50. They are left in place — editing a tamper-evident
log to hide your own noise is the wrong instinct — and writeLine now refuses the
default path under VITEST unless OS_AUDIT_LOG is stubbed, with a regression test.
Verified on the live :4005 build: apps_logs returns real hermes journal lines at
read scope, fs.write lands in the trail with actor and target, the scope refusal
lands as mcp.denied, sys_stats does not appear at all, and mso audit reads it
back.
2026-08-10 (mcp) — the VPS is drivable from ChatGPT, off by default (DONE)
An MCP server: OAuth 2.1 + PKCE in front of a hand-rolled JSON-RPC endpoint, so
ChatGPT / Claude.ai / Cursor can call the same host operations the web UI does.
Ported from the models-rahmanef-com implementation (read web/convex/mcp*.ts and
web/app/{mcp,oauth,.well-known} for the original) — but that one is Convex-backed
and mso has no database, so clients, codes and tokens live in ~/.mso/mcp.json under
the same atomic-write + fail-loud-on-corrupt rules as lib/auth/device-store.ts.
The kill switch is real. Without OS_MCP_ENABLED=1 every route 404s — /mcp,
both .well-known documents, all three /oauth endpoints. Not an unauthenticated
surface: no surface. Demo mode forces it off regardless.
Tools are thin calls into lib/host, and that is the whole security design. The
MCP surface inherits OS_FS_*_ROOTS, the credential denylist (~/.ssh, cloud and AI
tokens, and ~/.mso itself), the realpath escape checks and exec.ts's destructive
filter for free. Verified live on prod: a read-scope token asking for
~/.mso/config.json gets Access to credential/sensitive files is blocked, so it
cannot exfiltrate the BYOK key or the device allowlist. browser_status withholds the
Camoufox viewer URL and VNC password on purpose — that profile holds a live Google
session, and a tool result is a thing that leaves the box.
Scope ladder read < write < exec, chosen per token on the consent screen and capped
by OS_MCP_MAX_SCOPE. tools/list filters by it AND tools/call re-checks it, because
a client can call a name it was never shown.
/mcp is deliberately NOT under /api: proxy.ts blocks mutating /api that cannot
prove same-origin and an MCP client is cross-origin by definition. The bearer is the
control, not the CSRF gate. proxy.ts exempts /mcp, /oauth/token, /oauth/register
and /.well-known/oauth-* from that gate and the document CSP; /oauth/authorize is
NOT exempt — it is a real page and keeps its nonce.
Verified end to end on the live :4005 build, not just in tests: discovery returns
the right origin, a bearer-less POST 401s with WWW-Authenticate + resource_metadata,
DCR mints a client and rejects a plaintext redirect_uri, the token endpoint answers a
bogus code with invalid_grant, a read token lists exactly 8 read tools and gets real
sys_stats back, the same token is refused exec_run with a message that says how to
fix it, and mso mcp revoke kills it mid-flight. 53 unit tests alongside.
Shipped ON with OS_MCP_MAX_SCOPE=exec at the owner's request — the ceiling, not the
default; every token still starts at read on the consent screen.
2026-08-10 — audit follow-up: −4.4k lines, two eager chains off first load (DONE)
A 13-agent audit (6 dimension scanners, each with an adversarial verifier that had to refute its own dimension's claims, then a synthesis pass). 48 claims, 41 survived, 7 were killed — and the kills were worth as much as the finds. Shipped in five commits.
Behaviour fixes.
/api/prefswas fetched twice on every load — the appearance and quicklinks providers each pulled the whole 1.6 KB blob to read one key, both outside AuthGate, and both retry on window focus, so a signed-out tab-back fired two 401s. One shared in-flight promise, cleared on settle so the retry still refetches.- A failed app-chunk import left a spinner forever.
window-content.tsxcaught the rejection and dropped it — which also disabled the recovery its own comment named:register-sw.tsxself-heals a stale chunk fromunhandledrejection, and a handled rejection never fires that event. It now shows the failure with a reload button and rethrows. This is the deploy-day path (new build, old chunk ref), so it mattered. - Spotlight reported a dead host API as "No matches" — indistinguishable from an empty result, so an expired session looked like an empty folder. It keeps the error.
ResponsiveProviderallocated a fresh state object on everyresize, so React'sObject.isbailout could never fire — and this value is read at the shell root, so every event re-rendered the whole tree, each one paying a synchronousgetComputedStyle. Now one rAF-coalesced measurement that bails when the geometry is unchanged. Mobile firesresizeon every URL-bar collapse and keyboard open.
a11y (all pure additions): dock app icons had no accessible name at all (a
<Link> around a lucide <svg>; the hover panel holding the title is invisible, so
out of the a11y tree) — ~20 blank links. Login errors had no live region anywhere in
the auth slice, so "Incorrect password." was silent; the password field had only a
placeholder. Android recents cards were pointer-only divs. The toast stack was pinned
at a hardcoded 36 px while iOS floors --sai-top at 44, so it opened under the notch.
Perf — two eager chains, both measured on the live build.
- One 267 KB chunk (82 KB gzip) in the initial
<script>set carried macOS chrome and iOS chrome and all 10 shell features to every visitor, becauseDesktopChromeshared a module withSurface. It moved tocomponents/shells/macos/; all five shells now register throughregister-shells.tsxwithlazy(). −68 KB on a phone, −42 KB on a desktop. installAlfaSources()ran at module scope, so every signed-in load pulled the host-tool catalog + its 12run()closures + agent presets (88 KB) into the initial bundle AND firedGET /api/skills— 90 serialSKILL.mdreads, 602,672 bytes off disk, 60–80 ms, for a menu nothing renders until the user types/. os-shell registers a loader now; the composer's first render pulls it, and the skills fetch waits for the first/. Both needed a subscribe/notify seam, because the composer computes its item list during render on purpose — seechat-composer.tsx:45, which documents the exact bug auseMemoreintroduces here.
Deleted, ~2.0k lines of code + ~1.7k of docs, each verified to have zero consumers:
the os-browser Playwright sidecar's source (unit stopped and disabled for months, no
/api/v1/browser route, Browser has been Camoufox for two rewrites), the e2e shell
harness (e2e.sh:12 pointed $BROWSER at a script that does not exist, so all 7 checks
aborted on line 17), Share + Quick Look (registries with no producers — the only callers
of openQuickLook/share were the ?e2e=1 commands), cross-app DnD (the one setData
in the tree writes text/plain, never the payload mime, so the read half could only ever
return null), AppHeader/AppInspector + the vaul drawer branch behind it, shell-settings'
unreachable half, the manifest's never-set routing/titleSync flags, publicProxyUrl +
PROXY_BLOCKED_EXTERNALS, hostOf, resolveModel's info option, assetDir + two dead
env vars, and 5 finished plan docs. multipart.ts's hand-rolled O(n·m) subsequence scan
and copy-concat became Buffer#indexOf / Buffer.concat (buf had to become a Buffer:
Uint8Array#indexOf searches for a single byte value, not a subsequence).
Two of PROGRESS's own "deliberately NOT cut" entries were reversed (os-browser/,
scripts/e2e*) — see the note at the 2026-08-03 entry. AUDIT-2026-06-11.md was NOT cut:
its stated reason, five source comments citing it by finding number, still holds.
What the verifiers killed, which is the more useful half. Deleting the 3 non-default
OS personas (~2,000 lines) — reachable three ways (Settings picker, desktop right-click
"View as", a palette command each). Spaces + session Profiles — "palette-only" is not
unreachable when ⌘K is the launcher. defineFeature/Slot as dead configurability —
shell.manifest.ts:80 injects an 11th feature through it and the App Store's feature
toggles filter on it. SHELL-FIDELITY-PLAN.md — a live unstarted roadmap whose §8 table
is where globals.css's live --shell-* tokens come from. A contrast-script "134 hidden
failures" — arithmetic over two JSON keys that never co-occur; acting on it would have
broken four presets. And "optimize /api/skills?name=X" — 🔒 name is raw user input
validated nowhere else; the enumeration allowlist is the only thing making ../
structurally impossible, so the proposed path.join reopens traversal.
2026-08-04 (hydration, final) — the fourth cause closed; zero mismatches anywhere (DONE)
The architectural one the previous entry deliberately left open.
The shell now renders only after mount. Which shell to draw depends on three things
the server cannot know — the viewport (useResponsive measures window.innerWidth), the
persisted per-surface choice (localStorage sv:shell) and the wallpaper preference — so
SSR always guessed desktop/macOS and a phone client then rendered iOS. Two different trees
is a guaranteed mismatch, and React answered by discarding the hydrated tree and
re-rendering the entire shell client-side. Because Radix derives ids from useId, the
divergence surfaced in the dev overlay as mismatched DropdownMenuTrigger ids — a symptom
that sent the first look at it in the wrong direction.
Surface now returns a skeleton (#main-content + sizing + bg-background) until a
one-shot post-hydration flag flips, so the server HTML and the tree React hydrates are
identical by construction.
This is an improvement, not a trade-off, on the UX side. The old behaviour PAINTED the
macOS desktop on a phone and then swapped it for iOS — a flash of the wrong operating
system. A brief flash of the themed background is strictly better, and bg-background is
already the right light/dark value because the pre-hydration script in app/layout.tsx
sets data-theme before first paint. Nothing is lost to SEO: the catch-all is fully
dynamic and auth-gated, and the shell was never usable without JS.
The measured cost, stated plainly: mobile LCP 160 ms → 320 ms, because the shell is no longer painted from SSR. Desktop LCP 380 → 420 ms. Both remain far under the 2500 ms "good" threshold, and desktop CLS improved 0.008 → 0.001. The old 160 ms was painting a shell that was then thrown away and rebuilt, so it was never a real 160 ms to the content the user wanted.
Verified end to end on the production build: hydration clean on desktop and mobile,
0 JS errors across all 17 apps in both mobile shells (was 17/17 erroring), 17/17 still
render, shell resolution still correct (390 → ios, 412 → ios, 1280 → macos), no horizontal
overflow, skip link and its #main-content target both intact, smoke 4/4. Mobile
sub-24 px touch targets are down to one — the sr-only skip link, which is 1×1 by design.
2026-08-04 (hydration + mobile polish) — three of four hydration mismatches killed (DONE)
Chasing React #418, which had been firing on every page load and every app. A hydration
mismatch is not cosmetic: React discards the hydrated tree and re-renders the whole shell
on the client. Localised with a non-minified dev build in a throwaway git archive
tree on :4007 — the minified production message names nothing. Four distinct causes,
three fixed.
- The
nonceattribute on the theme-restore inline script. Browsers blank thenoncecontent attribute once CSP has consumed it (anti-exfiltration), so the DOM reportsnonce=""while the server HTML carried the real value. Dev build showed it verbatim:+ nonce="NjA3NDAxNWIt…"/- nonce="". Fixed withsuppressHydrationWarningon that one script. The nonce itself must stay — proxy.ts mints it per request and the strict CSP will not run the script without it. useWidgetState'sgetServerSnapshotreturned the livestate. React usesgetServerSnapshotfor the first client render while hydrating, and by then the module-levelstatehad already been read fromlocalStorage. So the server rendered the desktop widget layer off and hydration rendered it on, throwing the whole tree away. Now returns a frozen SSR default matchingload()'s no-localStorage branch.Clockcould not match, for two independent reasons: it capturesnew Date()at SSR time and again at hydration time, andtoLocaleTimeString/toLocaleDateStringresolve against the server's locale during SSR and the browser's on the client. Both are named on React's own hydration-mismatch page.suppressHydrationWarningon each branch — which is precisely the attribute's purpose — keeps the server text (no layout shift) and lets the client correct it on the next tick.
Result: the home route is hydration-clean on desktop and mobile in the production build. Verified against :4005, not just dev.
STILL OPEN, and architectural rather than a bug. Deep-linking into an app at phone
width still mismatches. The dev trace points at a Radix DropdownMenuTrigger's
useId-generated id, which is a symptom: responsive-provider.ts's initial()
deliberately returns desktop for SSR, so the server renders the macOS shell (menu bar
full of dropdowns) while the client computes mobile and renders iOS. Different trees →
different useId sequence. Closing it means changing what the server renders for the
shell (a neutral skeleton, or no shell until mount), which trades away SSR'd content and
risks a flash. Left for a deliberate decision rather than changed in passing.
Mobile polish shipped alongside, all from actually looking at the rendered pixels:
- Android home labels and clock were
foreground(dark) directly on a dark wallpaper. Now white + text-shadow, matching the treatment iOS home/app-library already used. The colour is set on the home grid container, not insideAppCell— that same cell is reused by the App Drawer, a light sheet where white would be invisible. Caught before shipping by checking the cell's other call site. Clock mode="date"hard-codestext-muted-foreground, correct on a card and invisible on a wallpaper. Overridden locally with a[&_div]:descendant selector — (0,1,1) beats the class deterministically, with no!importantand no API change to a component four shells share.- Files' history back said
aria-label="Back", identical to the two shell-level exit-app controls, so a screen reader announced "Back" three times with three different meanings. It is now "Previous folder"; "Back" is reserved for leaving an app.
Feature sweep: 17/17 apps render in both mobile shells, each with a reachable exit (iOS "Done", Android NavBar + header). No blank screens, no fatals.
2026-08-04 — every border-<color> utility in the app was dead, and that is why Android had no visible Back (DONE)
Started from a user report — "stuck in the Android shell, there is no back button, and the mobile back affordance is hidden generally". Both turned out to share one root cause that had nothing to do with the shells.
app/globals.css overrode every border-colour utility in the codebase. The line
* { box-sizing: border-box; border-color: var(--color-border); } sat outside any
@layer, and unlayered CSS beats every layered rule in the cascade. Tailwind 4 emits
all utilities into layers, so that single * selector silently won against all of them.
Measured in the live page before the fix — border-red-500, border-primary and
border-foreground/70 all computed to rgba(0,0,0,0.1), byte-identical to an element
with no class at all. 64 usages across 48 files, including 15 border-primary
selection states, 10 border-destructive/* danger states and 6 border-ring. Wrapping
the rule in @layer base fixes all of them at once; box-sizing moved with it because
box-border/box-content were subject to the same trap. After: border-primary →
rgb(31,109,240). A visible side effect on the desktop shell: the CPU meter bar in the
Today widget now renders — it had been drawing its fill in the default 10% grey.
The Android NavBar was transparent, so Back/Home/Recents were invisible. The row
carried text-foreground with no background of its own, and the Android wallpaper is
dark — dark-on-dark. It now carries bg-background/80 backdrop-blur-xl border-t, which
restores the token contract (background and foreground are a legible pair by
construction, whatever the theme). Home/Recents switched from border-foreground/70 to
border-current so an outline always follows its own button's colour; the back chevron
went size-5 → size-6. Measured after: scrim oklab(0.968…/0.8), icon rgb(28,28,31)
— roughly 15:1. The 48×48 targets were already correct; nothing was ever missing, it was
unreadable.
On standardising the two mobile shells: iOS exits an app with a labelled blue "Done" top-right, Android with the bottom NavBar back. Those are the correct platform metaphors and were deliberately kept — the actual defect was that one of the two could not be seen. Both are now visible, labelled, and ≥44 px.
2026-08-03 (UX) — a real browser pass, a demo instance back, and I broke prod proving it (DONE)
First pass that opened the product in a browser instead of reading the code. Also the first time this session damaged production, so that first.
I broke :4005, with the exact hazard I had documented hours earlier. Measuring bundle
output meant running bun run build twice in the prod checkout with no restart after.
next build wipes distDir first, so the running server was serving 500s with
Content-Type: text/plain for its own chunks and the browser refused to execute them.
Fixed by a restart; smoke green after. Two lessons worth more than the measurement:
scripts/verify-build.sh exists precisely for this and I did not use it, and a broken
deploy silently corrupts whatever you are measuring — see the retraction below.
RETRACTED: "the mobile-first product renders the desktop shell on phones." I reported
data-shell=macos at 390px, 412px and on a real iPhone UA, with a screenshot of a macOS
menu bar on a phone-sized viewport. It was entirely an artifact of the breakage above:
React never hydrated (its chunks were refused), so the effect that computes responsive
state never ran and the deliberate SSR default — desktop — stayed on screen. After the
restart: 390px → ios, 412px → ios, 1280px → macos, zero horizontal overflow.
Responsive shell selection works correctly. Nothing was wrong.
Measured on a healthy prod (Playwright, os-browser/node_modules):
| desktop 1280 | mobile 390 | |
|---|---|---|
| LCP | 380 ms | 160 ms |
| CLS | 0.008 | 0 |
| TTFB | 24 ms | 20 ms |
| transfer / requests | 194 KB / 29 | 231 KB / 30 |
Against a 2500 ms "good" LCP threshold there is nothing meaningful left to win here.
Fixed: 4 touch targets under the WCAG 2.5.8 24×24 floor, all on mobile — the three
iOS home-screen page dots were 19×19 (p-1.5 around a 7px dot) and the home indicator
was 17px tall. Both got a min-h/min-w floor; the dot and the 134px bar are visually
unchanged, only the hit area grew. Mobile now reports one "tiny" control and it is the
sr-only skip link, which is 1×1 by design and expands on focus.
A11y came back stronger than expected, recorded so nobody re-audits it: 77 icon
buttons, zero without an accessible name; the skip link exists and its
#main-content target resolves; the Launchpad overlay is both inert and
aria-hidden, so its 16 app links are correctly out of the tab order (a naive
querySelectorAll sweep counts them as unnamed — mine did, wrongly);
prefers-reduced-motion collapses durations to 1ms rather than 0 so animationend
still fires. Two of my own grep-based claims were wrong and the browser corrected both.
mso-demo.service is back, :4006, loopback-only — see CLAUDE.md. Demo mode disables
login, so a public bind would publish an unauthenticated shell; mock-data-only keeps the
blast radius small but exposing it stays the owner's call.
Hardening: /etc/logrotate.d/mso-audit now rotates ~/.mso/audit.log (weekly, 5 MB
cap, 8 generations, su rahman rahman since the file is 0600). Growth is only ~88 KB/mo
today, but it is append-only with no cap in code and this box serves prod.
STILL OPEN — React hydration error #418, reproducible on BOTH mobile and desktop with clean localStorage, so it is not the theme-restore inline script. A hydration mismatch makes React discard and re-render the tree client-side. Identifying the offending node needs a non-minified dev build; not chased here rather than guessed at.
2026-08-03 (docs) — reconciling every live doc against what the box actually does (DONE)
A sweep for claims that had quietly become false. History files (AUDIT-*,
SCORECARD-*, dated plans, this log's older entries) were left alone on purpose —
they describe what was true then. Only live instructional docs were touched.
What was actually wrong:
.env.examplewas missing 6 settable vars. Reconciled againstprocess.envin code:CAMOUFOX_NOVNC_URL,CAMOUFOX_VNC_PASSWD_TEXT,OS_MEMORY_STORE,OS_THREADS_DIR,NEXT_PUBLIC_COMMIT_SHA,NEXT_DEPLOYMENT_ID. CLAUDE.md's standing caveat ("it is missing several… grepprocess.env") is now a precise list of what stays out and why: framework-injected (NEXT_RUNTIME,NEXT_PUBLIC_BUILD_ID), systemd's (NOTIFY_SOCKET,WATCHDOG_USEC), the OS's (PATH,SHELL), test-only (E2E_BASE_URL,OPENCLAW_HOME), andOS_BROWSER_*, which belong to the retired sidecar rather than this app.CONTRIBUTING.mdtold contributors to runscripts/check-slices.mjs— deleted earlier the same day — and claimed "280+ tests" (1136). Its checklist now matches the four guards that really run, and warns that the hook is untracked and that--skip buildis deliberate.- The
/mso-browser-listskill was the worst offender. It describedos-browseras the Browser app, triggered on "why doesn't the browser work" and "browser status", and told the reader tosystemctl restart os-browser. All false: the Browser app is Camoufox, the unit is stopped +disabled,/api/v1/browser/*was deleted, theOS_BROWSER_URL/172.18.0.1wiring is Dokploy-era (prod is systemd), and its.envpath pointed at~/projects/os-browserinstead of~/projects/mso/os-browser. Rewritten, and itsdescriptionnow explicitly routes those trigger phrases to/mso-camoufox.browser-check.jsprinted the same dead architecture line; fixed. CLAUDE.mddocumented a demo that does not exist — nomso-demo.service, no/home/operator/projects/mso-demo. TheNEXT_PUBLIC_OS_DEMO=1flag is still real; the second checkout and :4006 unit are not. Its verification recipe also said to drive the demo "via os-browser", which is doubly gone — now points at Playwright directly.docs/SLICE-CATALOG.mdlisted 20 slices; there are 21 (docswas missing).docs/FAQ.mdstill advertised "280+ vitest tests" and only two audit passes.os-browser/README.mdopened "headless Chromium service for the Browser app".
Every claim written in this pass was checked against the box rather than assumed —
including one of my own: I wrote "four guards" and the hook has five # Guard lines.
Four run; the fifth is a Convex auto-deploy that no-ops here because there is no
convex/ dir. Said so rather than rounding.
2026-08-03 (later) — the two open items closed, and the health lens finds a silent way to lose the device allowlist (DONE)
Clearing both items the entry below left open.
Three of the four rm -rf / bypasses are closed. The patterns anchor the catastrophic
argument on \s, $ or *, so a / followed by ;, ) or " walked straight past them.
Rather than widen each regex — which leaks a new way in for every character you forget —
matchDestructive now splits the command on shell separators ([;&|()"'\\n]+) and tests each segment, so echo hi; rm -rf /, (rm -rf /) &, bash -c "rm -rf /"andecho $(rm -rf /)all land on a segment where the trailing/sits at end-of-string. **Ordering inside that function is load-bearing and pinned by a test:** the whole string is tested BEFORE the segments, because the fork-bomb pattern is built out of(){}|&;:` — the
very characters being split on — so segment-only testing would silently stop detecting it.
The fourth (HOME=/ rm -rf "$HOME") stays an it.fails(): the destructive argument only
exists after the shell expands the variable, which no static filter can see. Expected-fails
went 4 → 1 and the suite turns red if that ever starts being caught.
Accepted cost, pinned as its own test: quoted prose is now refused too —
git commit -m "never run rm -rf / on prod" is indistinguishable from
bash -c "rm -rf /" except by program name. Erring toward refusal; the escape hatch is
OS_EXEC_ALLOW_DESTRUCTIVE=1. Ordinary commands (ls -la /, cd / && ls, find / -name x,
systemctl status mso) were checked and still pass.
The health lens (the one that died) found a real data-loss path.
lib/auth/device-store.ts's read() returned an empty store for EVERY failure — and it
feeds a read-modify-write whose callers recordPending and approveDevice write
unconditionally. So one unparseable byte in ~/.mso/auth-devices.json meant the next login
attempt from an unapproved device read "no devices", then persisted that — wiping every
approved device and locking the owner out of their own host. recordPending is reachable
from the internet by anyone holding the password. Now only ENOENT (legit first run) yields
an empty store; corrupt JSON or EACCES throws. Costs a 500 on login; the old behaviour cost
the allowlist. device-store.test.ts is new (it had none) and its two key cases were
verified to fail against the old code.
lib/host/fs-upload.ts had zero tests despite being a write boundary behind
/api/v1/fs/upload. fs-upload.test.ts now pins the two things that matter: a part cannot
escape the destination (parent/deep/mid-path traversal, absolute paths, segment-only inputs)
and the 100 MiB cap stops bytes reaching disk, leaving no .tmp behind.
The rest of the health lens came back clean, and it is worth recording so nobody re-runs
it: 1 @ts-expect-error in total (in a test, justified), zero real any in non-test code,
1 empty catch (the inline theme script in app/layout.tsx, where a corrupt localStorage
must not block render), and 21 files with eslint-disable — all narrow, single-rule, and
carrying a reason. No secret has ever been committed: the two OS_SESSION_SECRET= hits in
git history are $(openssl …), $SECRET and a regex, not values. exec.ts is NOT untested
as a filename scan suggests — exec-filter.test.ts covers it.
1136 tests / 115 files (was 1115 / 113).
2026-08-03 — pnpm→bun, a 5-lens audit, and the gates that were never actually gating (DONE)
Four commits: 268747f (bun + audit fixes), 844eef3 (−836 lines), 674455b (dependency
- build gates, sharp CVE),
c201e8f(cleanup). All live on :4005 and pushed.
bun replaces pnpm as the installer — the runtime did NOT move. bun.lock is committed,
pnpm-lock.yaml is gone, .nvmrc/engines.node still pin Node 22, and prod's ExecStart
is still /usr/bin/npm run start. next/tsc/eslint/vitest carry #!/usr/bin/env node
shebangs and bun run honours them, so every tool still executes under Node. Measured, not
assumed: install warm 3.5 s → 2.6 s (marginal), script startup 318 ms → 8 ms (the actual
win — verify chains four). pnpm.onlyBuiltDependencies → trustedDependencies,
pnpm.overrides → overrides. Two traps now documented in CLAUDE.md and DEVELOPMENT.md:
bun test silently shadows the test script and exits 0 having run nothing, and bunx
downloads-and-runs a missing package (so post-deploy-smoke.sh calls
node_modules/.bin/vitest directly, never bunx).
A 5-lens audit ran; the 5th lens died and its ground was never covered. Lenses:
over-engineering, security, Next16/React19, bun blast-radius, repo health. Each finding was
handed to an adversarial verifier told to refute it. The repo-health lens hit a
StructuredOutput retry cap and returned nothing — so test-coverage reality, error
swallowing, eslint gaps and TypeScript escapes remain unaudited. The security core came
back clean under four separate attempts: all 51 routes verifyAuth first, path bounds
realpath before checking, and the CSRF gate in proxy.ts is not spoofable.
The largest real cost was one line. next.config.mjs is evaluated twice (once by
next build, once when next start boots), so a Date.now() deploymentId fallback
emitted two different ?dpl= values for the same chunk — the HTML referenced both and the
browser downloaded, parsed and executed ~160 KB gzip of entry chunks twice on every cold
load. Confirmed live, now zero ?dpl=. Note the key must be absent, not undefined:
undefined still emits an empty ?dpl=, which leaves chunk.js and chunk.js?dpl= as two
distinct URLs and the double download intact. env: { NEXT_PUBLIC_BUILD_ID } is unaffected —
env is inlined at build time for server and client, which is why it never had this bug.
Other perf: System Monitor (1.5 s) and Managed Apps (10 s) polled with no visibility gate, so
a backgrounded tab spent host CPU forever; the menu-bar CPU chip ran a second poller against
the endpoint the shared store already polled (~55 → ~20 req/min); hermes --version (0.44 s
CPU) re-forked every 10 s, now cached 60 s and dropped on any lifecycle action; xterm left the
entry chunk (340 → 334 KB gzip) — os-terminal/index.ts eagerly re-exported the module it
also code-split, and shell.manifest.ts imports that barrel eagerly.
Security fixed: the Camoufox profile (live Google SID/__Secure-1PSID/SAPISID +
LinkedIn li_at) and ~/.vnc were readable through fs/read and fs/zip — absent from
SENSITIVE_HOME while OS_FS_READ_ROOTS is ~; four live session cookie jars sat 0664 at
derivable /tmp paths (code fixed and the existing files chmod'd); a distributed login
lockout where six IPs inside their own 5/min allowance filled the 30/min global budget and the
owner's correct password then got 429 — the global budget is now charged only by a failed
password compare, with a regression test verified to fail on the old code; ~/.mso now created
mode: 0o700; the CLI login body moved from argv to stdin.
−836 net lines. 20 slice.json + check-slices.mjs (604 lines; one consumer validating 3
of 12 fields, and docs/AUDIT-2026-06-11 had already flagged 8 as describing a Convex auth
this app does not have), layouts.ts (a strict subset of profiles.ts), two CredentialStore
impls, useBadges/useProfiles, three documented-but-unread ShellManifest/Brand/
FeatureDescriptor fields, three image-editor barrel re-exports, and makeDragProps — the
producing half of the DnD seam, which had no callers, meaning nothing ever wrote DND_MIME
and the receiving half was unreachable. os-browser.service (retired sidecar, 135 MB, still
autostarting) stopped + disabled; the directory stays as the repo's only Playwright.
The gates were theatre; now they are not. Three discoveries, in order of how badly each was believed:
bun audithad never been run. First run found sharp <0.35.0 HIGH (libvips CVE-2026-33327/33328/35590/35591) sitting transitively under next. [email protected] pins^0.34.5and has no fixed release — only canary moved — sooverridesis the only fix. sharp 0.35.3, libvips 8.17.3 → 8.18.3,/_next/imagestill 200. sharp 0.35 also removed its install script, sobun pm untrustedis now two entries, not three.- Adding
audittoverifygates nothing: sc-git'sci.jshas a hardcodedSTEPS = ['typecheck','lint','test','build']and never invokesverify. The real gate had to go in.git/hooks/pre-push. - "Just remove
--skip build" would have been an outage on every push.ci.jsbuilds inprocess.cwd(), which for the hook ismso.service's WorkingDirectory, andnext builddeletes everything indistDirexcept/^(cache|dev|lock)/as its first act — and repeat builds rename every chunk and mint a newBUILD_ID, so already-served HTML stays broken afterwards too.--skip buildis load-bearing safety.scripts/verify-build.shbuilds a throwaway copy of HEAD inmktempinstead;node_modulesis copied, not symlinked (Turbopack hard-fails on a symlink pointing outside the filesystem root) and.env.localis deliberately not copied, so no secret lands in/tmp.
scripts/audit.mjs exists because bun audit fails closed — offline it exits 1, the same
code as a real advisory — so wired raw into a hook every network blip becomes a fake security
failure. The wrapper treats empty stdout as "unreachable, skip"; CI keeps the raw fail-closed
command on purpose, because a release gate must not pass an audit it could not perform. Also:
--json silently ignores both --audit-level and --ignore, and bun's JSON carries only an
opaque numeric id, so the readable GHSA is parsed out of the advisory URL.
Also fixed: the post-deploy gate was half dead. scripts/e2e/smoke.test.ts probed
/api/version and /api/v1/sys/cpu — neither ever existed in this repo (no git history for
either path). It had been asserting 404 == 200 since it was written, which is exactly how a
gate stops being run. Repointed at /api/health + /api/v1/sys/stats; 4/4 green.
Push now costs ~70 s (was ~47 s) and prints audit: clean at high/critical. +
build: HEAD compiles (out-of-tree). — if those two lines are missing, the wiring is gone.
The hook is untracked, so an sc-git hook reinstall silently reverts all of this and re-adds
the deleted check-slices.mjs line, which would block every push.
Still open: (1) lib/host/exec-filter.test.ts documents four it.fails() bypasses of the
rm -rf / guard (; chain, subshell, bash -c "…", HOME=/ rm -rf "$HOME"). Exec is
human-approval-gated and an authenticated owner has full shell anyway, so this degrades the
DANGER badge rather than being RCE — but a regex over shell strings is the wrong shape; the fix
is to split on shell metacharacters and check each segment. (2) The repo-health lens above.
→ Both closed the same day; see the entry above this one.
2026-07-30 — v0.2.0: Alfa can act on the host, and a release gate that found four reasons it should not ship yet (DONE)
An adversarial gate before announcing the agentic harness: five probes (contract vs code, the approval boundary, live behaviour, doc truth, ship blockers), each handed to a skeptic told to refute it against one bar — would this embarrass or endanger someone who self-hosts MSO because the release said the AI can act on their host? 46 findings, 44 survived, 4 blocked the release. All four are fixed here.
1. app.open was a way around the approval boundary. It is effect: "read" on the
stated grounds that opening a window "touches nothing on the host". True for fourteen apps
and false for two: claude-code mounts a PTY that immediately runs
claude --dangerously-skip-permissions, and os-terminal mounts a login shell. The app
name comes from the model, so prompt injection reached it, and pty.ts already records
that keystrokes are unaudited and the destructive-command regex cannot apply there.
registry.test.ts kept pty.open away from the model; nothing kept away the window that
wraps one. run() now refuses both by id, the description no longer advertises a terminal,
and a test pins both halves.
2. The same tool silently lied about the other twelve. It called
openWindow(app, app) with the model's raw string, but the registry keys by id while
shell.manifest.ts gives most apps a different slug — and the description advertises
the slugs. So "open Files" rendered Unknown app: files and returned opened files. Both
the user and the model were told it had worked. It now resolves slug-or-id against
BUILTIN_APPS using the same predicate as use-url-sync, and throws on a name it cannot
resolve.
3. The Agents UI asserted a permission boundary that did not exist. A "Generalist /
Curated — by skill" switch, a per-agent Skills grant list, and counters reading
"Ops · 2 skills · 11 tools" — while use-host-commands.ts returns HOST_AI_TOOLS
unconditionally, with no agent in scope. All 18 tools went every time. Not exploitable —
mutating tools still park a card — but someone who curated a System-only agent was handing
the model fs.read over their entire read jail and believing they had not. CONTRACT.md
already required this removal in writing; this commit performs it and marks it done.
4. The zero-friction provider turns the headline feature off. The ChatGPT OAuth path
never forwards the tools array (codex-stream.ts sends no tools field), so Alfa answers
fluently and cannot call anything — and "chat-only" appeared only in code comments. The
sign-in button now says so. This is what the live instance was running, which is why
the harness was doing nothing there.
Docs. README's Security warning said nothing about the assistant being able to act on
the host; it now names all 18 tools by tier, says that everything Alfa reads goes to the
model provider on every turn, states that a read file is untrusted input and the card is
the only thing between it and an exec.run, and says plainly that Agents and Skills are
organisation rather than permissions. Also removed a shipped pre-launch TODO that called
the maintainer's own auth-gated cockpit a demo.
Version 0.2.0 — first tag since wave1-safety, 191 commits back. typecheck + lint + 1,096
tests + build green; the manual workflow_dispatch CI passed from a clean checkout at
run 30564867120, which is the only lockfile-drift check that exists.
2026-07-30 — A repo-wide dead-weight sweep before the agentic-harness release (DONE)
bccd0b1..HEAD. An adversarial audit — six parallel sweeps (orphan modules, whole
directories, dependencies, dead code in live files, docs, assets), each one's findings then
handed to a skeptic whose job was to REFUTE them. 47 candidates, 22 survived. The skeptic
earned its keep: it killed a proposed 21-line barrel trim that would have been a build
break (appshell's own features/* subtree imports the barrel BY ALIAS, so a
"used outside this directory?" predicate reports live exports as dead), and it saved
os-browser/ by starting it — dormant, not dead, and still the repo's only Playwright
install, which scripts/gen-readme-media.mjs imports.
Cut, in order of size. mock-os/ (101 files, 5.7k lines, 6.6 MB) — an HTML+babel design
prototype deliberately excluded from the build, the lint pass and the coverage report, i.e.
excluded from everything, which is the definition of weight without load. docs/PLAN.md and
docs/MULTISHELL-PLAN.md: the first contradicted by shipped code in every section, the
second's sibling repo gone and its one unique decision reversed by PROGRESS.md:574. 15
slice.manifest.json stubs ("generated": "stub", 8 naming a convex/ directory that does
not exist) — image-picker and quicklinks stay, being hand-written docs rather than
stubs. rr.json, an inert consumer manifest describing the Convex stack removed in Phase
15. appshellConfig, a config export declaring no config. Six symbols with exactly one
repo-wide hit each, their own declaration. docs/media/hero-desktop.png, 1.2 MB the README
stopped referencing when it moved to mso-hero.webp, plus openApp() and the throwaway
~/readme-showcase folder that existed only to dress that one screenshot.
Two comments that were simply false, which is worse than dead code because it is read as
fact: vitest.config.mts said coverage was inert pending an install that had already
happened, and CONTRIBUTING.md said there is no CI.
One bug the sweep surfaced. The service worker cached /icon-192.png and
/icon-512.png, which have never existed — app/manifest.ts has always pointed at the
SVGs. Next's catch-all answers an unknown path with the app HTML and a 200, so addAll()
never threw; it cached the HTML shell under two icon URLs, which is precisely what the
comment above it promises the SW never does.
CI moved off hosted runners. ci.yml ran on every push to main at ~80 s of billed
runner time, duplicating a pre-push hook that already gates typecheck/lint/test/check
locally. It is workflow_dispatch now. Three of its steps are genuinely not reproducible
locally — clean-checkout pnpm install --frozen-lockfile (the only lockfile-drift check),
bash -n scripts/install.sh, and pnpm build — so the file says to run it by hand before a
release rather than being deleted.
Deliberately NOT cut, each with a reason: os-browser/ (a documented, whitelisted,
working service); docs/{ARCHITECTURE,AUDIT-2026-06-11,SCORECARD-2026-06-14}.md
(banner-kept history, and AUDIT-06-11 is cited by name from three source files);
scripts/e2e* (dormant, revived by one node os-browser/server.mjs);
[REVERSED 2026-08-10: os-browser/'s source, scripts/e2e* and
SCORECARD-2026-06-14.md were deleted. The service had been stopped AND disabled
for months with no /api/v1/browser route left to call it, which took the e2e
harness with it — e2e.sh also pointed at a $BROWSER script that does not exist,
so all 7 checks aborted on line 17. AUDIT-2026-06-11.md stays, for exactly the
reason given here.]
useBadges/useLayouts/useProfiles/listProfiles (dead here, but rr's appshell calls
listProfiles — cutting forks the lifted slice and they return on the next merge); the
3,060 unread token entries in registry-data.json (a verbatim upstream mirror; pruning it
forks the file and breaks check-contrast's pairs); the postcss devDependency (a one-line
win that costs a 258 KB lockfile regeneration on the eve of a release).
Deleted docs and trees are recoverable with git show bccd0b1:<path>; the untracked ones —
mock-os/Apple-clone-app/, public/MSO_Brand_Assets_Current/, 13 one-shot June probe
scripts — are in ~/archive/mso-cleanup-2026-07-30/, since git could never bring those
back. Net: 1,047 → 930 tracked files, −6.3k lines, −9 MB. typecheck + lint + 1,095 tests +
build + cycles + slices green.
2026-07-30 — Hermes reached the iframe; three gates were closing it (DONE)
The Hermes window rendered {"error":"managed application upstream unavailable"}. Three
separate gates, each one uncovered only after the previous was open, and each one a real
gap in the install path rather than a fault in a running app.
1. The install never installed the dashboard (scripts/managed-app-install).
hermes gateway install creates hermes-gateway.service — Telegram/Discord/WhatsApp
plumbing — and binds nothing on 9119, which is the port HERMES_DASHBOARD_URL points at.
So a Hermes MSO had just reported as installed, running, healthy served a connection
refused. This host hid the gap for months because its 9119 unit was hand-written and
predates the installer; deleting it on 2026-07-29 is what exposed the bug. There is no
hermes dashboard install upstream, so the unit is ours now, written at install time.
hermes serve is not a substitute — it answers /api/* and 404s the web UI by design.
No --skip-build: the first start builds web_dist in ~1 min, every later start finds
it current and is up in 2 s, and --skip-build would turn a missing dist into a
permanently broken service instead of a slow first boot.
2. The proxy stripped the credential the SPA needs (lib/managed-apps/proxy-headers.ts).
On a loopback bind Hermes mints an ephemeral token per process, injects it into the SPA
HTML, and requires it back as X-Hermes-Session-Token on every /api/* fetch. It was not
on the request allowlist, so the shell rendered perfectly and every request under it 401'd:
sidebar, no data. Forwarded per-app (APP_REQUEST_HEADERS), not globally — it is one
upstream's credential. Safe in a way authorization is not: no browser attaches this header
on its own, so it can never become ambient credential.
3. The WebSocket upgrade failed Hermes' own rebinding guard (proxy.ts,
upstreamSocketHeaders). FastAPI runs no HTTP middleware for WebSocket routes, so Hermes
repeats the DNS-rebinding Host/Origin check inside the handler and closed every chat socket
4403 → "connection interrupted (code 1006)", reconnecting forever, while every plain fetch
on the same page worked. The upgrade now presents the loopback Host/Origin for Hermes
only: OpenClaw matches its allowedOrigins against the origin AS PRESENTED, so the same
rewrite would break it. Rewriting these two headers gives an attacker nothing — ?token= /
?ticket= in the query is the credential, and it rides through untouched. The test that
asserted the opposite was asserting a false premise (that Hermes binds 0.0.0.0).
OpenClaw, found while testing. Its Control UI refused the socket with "Browser origin not
allowed": gateway.controlUi.allowedOrigins held only the retired oc.rahmanef.com, restored
from a 2026-07-25 backup by the job.restore.succeeded at 19:55 on 2026-07-29 — config
restore replaying pre-split state. onboard has no flag for it, so the installer sets it from
MSO_INSTALL_APP_ORIGIN (managedAppOrigin(id)), origin only, never a wildcard. Remaining
step is auth by design: the Control UI wants the gateway token pasted (reason=token_missing).
Verified end to end against the live cockpit with Playwright as an approved device: Sessions,
Models, Skills, Cron and Chat all load, all three sockets (/api/ws, /api/events,
/api/pty) stay open, model badge reads live, zero failed requests.
2026-07-28 — Alfa becomes one assistant; the browser becomes real; four security fixes (DONE)
ab03b3e..c30e6e6, 18 commits. Three threads: reversing a design that had drifted into
fiction, making the browser and the assistant actually work on a phone, and closing four
security holes. Read the failures section at the end — four of these commits shipped
defects that only a later audit caught, and that pattern is the most useful thing here.
Hermes and OpenClaw are ordinary apps, not shell modes (a2c3882). MSO could swap its
entire shell into a per-app "workspace mode": localStorage picked a mode, the app list was
filtered to a per-mode set, and a pipeline scraped each upstream's BUILT SPA bundle with six
regexes to spawn one MSO window per upstream nav route. Both dashboards already ship their own
sidebar, so all of that rebuilt navigation they hand us for free — held up by regexes against
minified third-party JS. Deleted: os-shell/workspace-mode.ts, the WorkspaceModeControl
capability, the Dashboard <select>, the Control Centre tile, the right-click submenu, and the
whole discovery pipeline (features.ts, feature-parser.ts, dynamic-features.tsx,
feature-icons.ts, the /features route). −1,048 net. noDock came off both descriptors first,
or they would have vanished from the dock, start menu, Android home and Dashboard sidebar.
The Browser is a real Firefox (5017353, c8be397, 779f2ba). The iframe browser could
only ever render the minority of the web that permits framing — X-Frame-Options refuses the
rest — so it was chrome around a blank rectangle. It is now Camoufox (anti-fingerprinting
Firefox) on a headless X display, streamed over noVNC. Two mobile blockers had to go with it:
vnc_lite.html has no focusable input at all, so on touch the OS keyboard never opened and the
remote browser could not receive a keystroke; and scale=true painted a 1440x920 desktop at
0.273x inside a 393px window with ~60% empty letterbox — the "black rectangle" the owner
reported. vnc.html + resize=remote gives 1:1 pixels, and needs a window manager on the
display (matchbox) or the browser window never reflows on the RANDR change. 779f2ba gave the
window power over the host session, so hiding the app no longer leaves a browser, an Xvfb and an
x11vnc running for nobody.
Alfa is one conversation across every feature (5e025ff, 818a77d, ed8e8fd). It used to
be two disconnected chats: the Assistant app ran the real agent, while the Inspector ran a
second toolless chat whose state was thrown away on every app switch (key={appId} remount).
Now one module store, one engine registered lazily by the panel, and many views onto it —
including a bottom sheet on mobile, where Alfa did not exist at all because rightPanel is
rendered only by the macOS and Windows shells. Every turn is tagged with the app it came from, so
a task carried Files → Terminal → Browser reads as one story. @agent and /skill completion
landed in ONE composer every AI input shares; / fires only as the first character, because this
is a VPS cockpit and ls /home/operator must not open a menu.
The AI subsystem stopped lying (52949ec, badef71, 3287f61, 79938be, 87ac78a,
c30e6e6). There were two tool catalogs: 45 hand-written descriptors beside 18 executable tools,
sharing exactly ONE name (apps.list) and disagreeing about what it did. The other 44 described
capabilities the model could never call. OS_TOOLS is a VIEW of HOST_TOOLS now. The agent was a
per-mount hook, so the sheet and dock could not read it — which is why @agent was cosmetic; it
is a module store now and a pick actually switches, with "Answering as " so the switch is
visible. The persona moved from a fake user turn (injected once, when history was empty, freezing
turn zero's agent forever) into a per-request system prompt. CONTRACT.md in the assistant slice
now states what an Agent, Tool, Skill and Playbook each are, and lists the gaps rather than hiding
them.
Security (a8a3c72, a980729, c8be397, 5017353):
- An unauthenticated permanent lockout of the owner. The login limiter incremented its global counter before the per-IP check and unconditionally, so one flooding IP burned the process-wide budget and every other caller — including the owner, from a different address, with the correct password — got 429 for as long as the flood ran. No credential, from the public internet, indefinitely.
- A credential-copy escape.
copy(~/projects → ~/backup)duplicated the cockpit's own.env.localpast the credential gate, and/api/v1/fs/readwould then serveOS_SESSION_SECRET. Reachable on the DEFAULT roots. - The camoufox VNC bridge was gated only by the presence of a cookie NAMED
session, soCookie: session=xfrom anywhere reached a live keyboard and mouse. It is behind the same verified-session check as/api/v1/execnow. - x11vnc ran
-nopwfronting a logged-in browser profile. Password set, and the launcher now refuses to start without one.
Also: real product marks for Hermes/OpenClaw/Camoufox instead of approximate lucide glyphs;
skills bundled in-repo so a fresh install has a catalog; zip exit 18 no longer throws away a
complete archive over one unreadable file; -x */name/* fixed to also match at the archive root.
What broke, and how it was caught. Four commits shipped defects that passed typecheck, ~1000 tests AND a live browser check, and were found only by a later adversarial audit:
52949ecpruned unknown tool ids from saved data.mergeBuiltinslets a SAVED copy win over the fresh preset, so every existing install would have had its five builtin skills emptied. Fresh installs were fine — which is exactly why nothing caught it. Fixed inbadef71by MIGRATING ids instead of dropping them.5e025ffcached the resolved engine forever and kept two busy flags, so sends went to a dead closure and a send mid-run was swallowed after the composer had cleared the text. A mutate tool asked for from the mobile sheet hung the agent forever with no Approve button anywhere. Fixed ined8e8fd.3287f61put the store on the eager client entry chain with an unguardedlocalStorageread, so a browser with site data blocked would lose the whole cockpit rather than one window — and79938be, meant to fix it, did not:typeof localStorageALSO throws when the getter throws. It also froze the store at page load, so a second tab silently clobbered agents created in the first. Both fixed inc30e6e6.
Every one failed only for a returning user, a second tab, a denied-storage browser, or a second interaction. A fresh-install happy path proves nothing in this codebase.
Deliberately not done: agent tool scoping stays fiction-free by deletion rather than
enforcement (a per-agent tool array would also cold-miss the prompt cache on every switch, and the
per-call approval card is a better lock); the Skill → Playbook rename; wiring
Skill.starters; caching /api/skills (~90 files per call).
2026-07-24/25 — Managed applications: Hermes + OpenClaw, each on its own origin (DONE)
Partly superseded by
a2c3882(2026-07-28): the workspace modes and feature discovery work below was REVERSED — Hermes and OpenClaw are ordinary app windows now, and the SPA-bundle parsers are deleted. The origin split, the proxy hardening, the update centre and the registry all stand unchanged. Kept because the work happened and the reasoning is why the reversal was right.
MSO becomes the control plane for applications that stay separate. Hermes and OpenClaw keep
their own runtime, config, data, versions, health, logs and backups; nothing is copied, forked or
merged into this repo, no DOM is scraped, and nothing under ~/.hermes/ or ~/.openclaw/ is ever
written — the only writes land in ~/.mso/. Everything goes through their own CLIs, their own
loopback HTTP surfaces, and systemd/docker. Shipped as c411187 → 52cfff5 → 0feaab4 →
5b4b5c9 → d1fbd85 → c597d08 → d880f68. (3b45b8e, same session, closed an unrelated
hole: the camoufox VNC rewrite was gated only by the presence of a cookie named session, so it
is commented out and answers 403 until a real check can run in the nodejs middleware runtime.)
tsc + eslint clean, vitest 90 files / 965 passing, deployed on :4005.
- Registry (
c411187) —lib/managed-apps/: catalog (command, candidate unit + container names, loopback dashboard URL, state dir, env overrides), manager (detect → state → health → version → actions → backup → logs, one in-flight action per app), runner (execFile,shell: false, argv arrays, 128 KB cap, timeouts — no string ever reaches a shell). Four routes under/api/v1/managed-apps, every oneverifyAuth()first; actions are demo-blocked, rate-limited 12/min and audited asmanaged-app.action. Backup copies~/<stateDir>into~/.mso/backups/<id>/<stamp>/and (as first shipped) refused a tree containing symlinks — replaced later this phase, see the fix bullet; logs are journalctl /docker logswith bearer/token/secret/password redaction. - Workspace modes + real feature discovery — REVERSED in
a2c3882, all of this is deleted. (52cfff5,0feaab4,5b4b5c9) —plain | hermes | openclawinlocalStorage(mso:workspace-mode), orthogonal to Shell Style, with a right-click Workspace submenu on all five shells sharing one store with the Dashboard select. Each app's navigation is parsed from its own installed bundle + plugin API, not hard-coded: Hermes 18 nav entries + 2 plugin tabs (verified againstweb_dist/assets/index-*.jsand/api/dashboard/plugins), OpenClaw 26 routes fromapp-route-paths-*.jsof which 24 are offered (workboard/pluginare flag-gated →available:false). 60 s cache, min-length parse guard, and an unreachable upstream yields nothing rather than tiles that 404. - Proxy hardening (
5b4b5c9,c597d08) — upstream must be loopback; cookies namespacedmapp_<id>_and pinned to the mount so the msosessionnever crosses;authorization/www-authenticatenever relayed; off-origin redirects refused (open redirect and a CSP path-matching bypass); upstream service workers 404'd; request bodies counted as they stream (a chunked body has nocontent-length); route errors carryframe-ancestorsor the browser refuses to display them. The emitted CSP is now intersected with the upstream's own per directive — OpenClaw's sha256-pinned inline scripts and narrowconnect-srcsurvive, itsframe-ancestors 'none'does not, and only hashes are ever copied, never nonces. - Every session cookie verified (
d1fbd85) — cookies are isolated by neither port nor path, so a planted secondsession=sorting first made every request fail HMAC and logged the owner out of their own cockpit. Each candidate is checked; the first that holds up wins. - Origin split (
d880f68) — the iframe needsallow-same-originor the SPAs do not boot, and on the cockpit origin that made upstream JS same-origin with the cockpit:window.top.fetch→/api/v1/exec/runwith the user's session, which no CSP can stop (a policy binds a realm, not a reference across realms). Each dashboard now has its own host on this same process ({id}.mso.example.com, DNS +/etc/dokploy/traefik/dynamic/mso-managed-apps.yml), sowindow.topis opaque — measured in Chromium 148, with a same-origin control that still breaks through.proxy.tsrewrites every path on an app host into that app's proxy and 404s the rest (matcher widened to/(.*), CSRF check moved ahead of the rewrite,Hostauthoritative overx-forwarded-host); an unclaimed name in the namespace 404s so a DNS edit alone cannot hand out an authenticated cockpit. Root-mounted means the document is no longer rewritten at all (no<base href>, no rebasing, no fetch shim, nothing to pin), the policy is origin-scoped,frame-ancestorsnames the cockpit from deployment env only, andimg-srcdrops itshttps:wildcard (the widened cookie would makenew Image().srcan existence oracle). The session cookie gained an optionalDomainand is cleared with and without it;SameSite=Strictis unchanged and still correct because the app hosts share the registrable domain. - Verified live, not just unit-tested:
https://hermes.mso.example.com/andopenclaw.…answer over TLS with a valid cert;/api/v1/exec/runand/api/v1/sys/statson an app host come back as the proxy's own 401 withx-middleware-rewrite: /api/v1/managed-apps/<id>/proxy/…(the cockpit route is not reachable there);staging.os.…and/_next/*on an app host 404; the cockpit itself is untouched. - Env is one decision in two variables —
NEXT_PUBLIC_MANAGED_APP_HOST_TEMPLATE+OS_SESSION_COOKIE_DOMAIN, set beforepnpm build(theNEXT_PUBLIC_one is inlined into the client bundle). Unset = single-origin mode, still the dev/demo/rollback path, with thewindow.topreach open and the path-scoped CSP as the only containment. - Two defects found by writing the docs, and fixed in the same phase. Documenting the
subsystem against the live host is what surfaced them; both were live in a shipped build and both
were invisible without a test, so
lib/managed-apps/manager.test.ts(5 cases) now pins them. (1) Detection ransystemctl is-active <unit>and treated anything that was not "could not be found" as "the unit exists but is inactive" — but on systemd 255 an unknown unit printsinactivewith rc 4 and an empty stderr, so the first configured name always won. OpenClaw's catalog led withopenclaw.service, which does not exist here, so its card readstoppedwithhealthy: null, empty logs (-- No entries --) and 409 on every lifecycle action while its gateway served. Nowsystemctl [--user] show -p LoadState -p ActiveStateper scope: rc ≠ 0 is "no answer" and falls through,LoadState=not-foundskips the name, otherwiseActiveStatedecides.catalog.tsalso listsopenclaw-gateway.servicefirst, though ordering no longer decides correctness. Live after the fix, both apps through the reallistManagedApps():hermes | systemd | running | healthy=true | dash=trueandopenclaw | systemd | running | healthy=true | dash=true. (2) Backup walked the tree and threw on the first symlink;~/.hermeshas 58 and~/.openclaw2063, so the action failed for every real install and~/.mso/backups/was never created (a success would have copied 2.7 GB + 1.7 GB). The guard is gone;fs.cpnow takes a filter that skipsnode_modules/.venv/venv/__pycache__/.git/.cache/backups— the last being the app's own 1.1 GB backup dir — and skips symlinks (neither followed, which would copy bytes from outside the app, nor recreated, which would let a restore write outside the tree). The source now honourshomeDir, soHERMES_HOMEis no longer ignored, andmanifest.jsongainedsource+skipped: {symlinks, dirs, dirNames}. Measured with those exclusions: 366 MB and 237 MB, on 227 GB free. - Open, and documented as open: no restore code, so a rollback is a manual
cp -aand the manifest has no inventory or checksum to verify a snapshot; no update center (check-update, channels, update, rollback, uninstall, install wizard); OpenClaw's control UI is WebSocket-driven and a route handler cannot service anUpgrade, so its panels stay empty and those features open on a CLI view with the reason stated; the docker andpackagedetection branches have no test and no install here to exercise them; no notifications, no resource-aware behaviour, no start-on-boot; no integration or journey tests;state: "error"is never produced andmanaged-app.actionaudit lines still carryactor: null; the workspace switcher is not yet a visible control in the macOS/Windows/iOS/Android chrome; an upstream can still broaden its ownconnect-srcto a third-party https host it declares (never to the cockpit). The split is a browser-realm boundary only — a plugin installed into either app runs inside that daemon and can run host commands. - Docs:
ARCHITECTURE.md(request-path diagram + the managed-app section),SECURITY.md(origin split as a first-class boundary + operational tripwires),README.md, the operator guide indocs/MANAGED-APPS.md, and per-appdocs/HERMES-INTEGRATION.md+docs/OPENCLAW-INTEGRATION.md(units, ports, auth models, discovery, upgrade tripwires). All re-checked against the code and the live host after the two fixes above.
2026-07-16 (round 8) — iOS editors long-tail: a11y + Dialog→sheet (DONE)
Closed the round-7 logged editor tail (owner-requested). Presentation-only (canvases untouched per
§6). a11y: coarse-pointer 44px across editor chrome in 10 files (code-editor, image-editor,
reel-editor, media-viewer, image-picker). Dialog→sheet: 6 raw <Dialog>s → house
ResponsiveDialog/FormDrawer (bottom sheet on touch) — reel settings + file-browser, media-studio
save-image, files zip, os-settings model-catalog (trigger-hoist + ScrollArea→Body), image-picker
(h-[440px]→flex-1); code-editor close-guard keeps its correct centered iOS alert. Added select to
the globals coarse rule. tsc + eslint clean, vitest 689, deployed :4005 health 200. Detail in
IOS-PARITY-REFACTOR-PLAN.md §8, round 8 (doc deleted 2026-08-10).
2026-07-16 (round 7) — iOS touch-target a11y sweep (P4 long-tail) (DONE)
Owner requested the iOS-parity optional long-tail. A 10-agent adversarial re-audit found 0
mis-gates (seam discipline held — the other four shells are provably unaffected) + 63 gaps (49
sub-44px touch targets, 8 dialog→sheet, 6 regressions from the round 1–6 AI work — the 14px app root
makes h-8=28px / h-9=31.5px fall short). Fixed the high-ROI subset: one @media(pointer:coarse)
globals.css rule for all inputs/selects/menuitems (~25 targets), 2 shared primitives
(responsive-toolbar, file-tree dir), 46 per-slice button/row 44px appends (6-agent disjoint
fan-out), and widget-picker Dialog→ResponsiveDialog sheet. Editors long-tail + the model-catalog
scroll-restructure logged as remaining. tsc + eslint clean, vitest 689 green, deployed :4005
health 200. Full detail was in IOS-PARITY-REFACTOR-PLAN.md §8, round 7 (doc deleted 2026-08-10).
2026-07-16 (round 6) — "Alfa, forget this" tool (DONE)
Twin of memory.remember: a memory.forget host-tool (read-tier) that matches saved
facts by phrase (substring), deletes each match via /api/memory, and reports what it
removed. Catalog entry + HOST_SYSTEM guidance + registry test. tsc + lint + vitest green.
Also added the gitignored root progress.md (local session log).
2026-07-16 (round 5) — "Alfa, remember this" tool (DONE)
Alfa can now save facts to memory itself, not just via Settings: a memory.remember
host-tool (read-tier — runs immediately, no approval card, since it's a benign owner-scoped
write) that POSTs to /api/memory. One catalog entry (host-tools/catalog.ts) + a HOST_SYSTEM
guidance line; the registry test covers it as a read tool. tsc + lint + vitest green. It
complements the manual Settings → Alfa memory panel (both write the same ~/.mso/memory.json).
Not redeployed — build + restart to activate.
2026-07-16 (round 4) — Alfa chat history (YAML threads) + cross-session memory (DONE)
Ports 2 & 3 of the models-rahmanef-com picks. tsc + lint + vitest (full suite + 4 new store tests) green. Store logic is unit-tested; the full UI click-through (send → persist → resume; add fact → Alfa recalls it) is best exercised on the deploy (it needs a real provider key to stream).
- Chat history — Alfa was stateless; now every completed turn persists to a YAML thread under
~/.mso/threads/(lib/ai/threads.ts— path-jailed filenames, atomic write)./api/threads(list/get/save/delete). A History drawer (thread-list.tsx) in the Alfa header lists saved chats; resume restores BOTH the display bubbles and the wire history so the chat continues; New starts fresh. Persistence factored into ause-thread-persistencehook. YAML (not JSON) per the owner's request — readable session files (yamldep added). - Cross-session memory — durable facts recalled into Alfa's system prompt, matched to the latest
user turn by word overlap (
lib/ai/memory.ts;~/.mso/memory.json)./api/memory(list/add/delete). The assistant route recalls + injects for EVERY provider path (codex/anthropic/openai). - Token savers — Settings → AI → Output style: Normal / Caveman (terse) / Ponytail (lazy senior
dev) → appended to the system prompt (
OsConfig.tokenSaver). - New Settings "Alfa memory" panel (
memory-section.tsx) under the AI section: output-style picker + add/delete facts. Not redeployed — build + restart to activate.
2026-07-16 (round 3) — Model catalog browser (DONE)
First of three models-rahmanef-com feature ports the owner picked (catalog browser · chat history · cross-session memory). tsc + lint + vitest green.
- Model catalog browser —
/api/modelsnow carries capability/pricing meta (context window, $/M input+output, tool/reasoning/vision support) from the models.dev catalog; a searchable Browse dialog (model-catalog.tsx) in Settings → AI lists the selected provider's models with that meta, click to set the model. Pure UI over the vendored@rahmanef/modelscatalog; degrades to "No catalog" for custom/OAuth providers (not in models.dev). Not redeployed — build + restart to activate.
Chat history (YAML thread store) + cross-session memory are next.
2026-07-16 (round 2) — BYOK OAuth: "Sign in with OpenAI" (Codex device-code) (DONE)
Phase D1 of DRAWER-MENU-BYOK-PLAN — the explicit ask ("oauth ai openai"). tsc + lint + vitest (301) green; the Codex device-flow start verified against the live OpenAI endpoint (HTTP 200 + user_code). The poll→token→chat round-trip needs the owner's ChatGPT authorization to exercise.
- OAuth framework — token bundles in the 0600 host config (
OsConfig.oauthTokens), transient handshake state in-memory (lib/ai/oauth/flow-state.ts), a per-provider start/poll route (app/api/oauth/[provider]/route.ts). OAuth providers surface in the connected-list (kindoauth), selectable + deletable. - OpenAI Codex (device-code) —
lib/ai/oauth/codex.ts(start/poll/exchange/refresh +decodeAccountId+ models) + a bespoke ChatGPT-backend Responses streamer (lib/ai/codex-stream.ts): the platform/chat/completionspath does NOT work — Codex hitschatgpt.com/backend-api/codex/responseswith the OAuth bearer, the account id decoded from the token JWT, and SSEresponse.output_text.delta. Public Codex-CLI client id (no secret, no registration). The assistant route bypassesresolveModelforopenai-codex, refreshes the token (120 s margin) before each call, streams viastreamCodex. - UI — Settings AI panel: "Sign in with OpenAI (ChatGPT)" → device-code (shows the user
code, opens the verification page, polls to completion).
oauth-connect.tsx; the active provider's key row + Test hide for OAuth providers. - Caveats (documented): Codex is a reverse-engineered CONSUMER endpoint — needs a ChatGPT Plus/Pro subscription, can break if OpenAI changes it, and is chat-only (no Alfa tools). Tokens are stored plaintext in the 0600 host file (mso's existing posture; at-rest encryption is a later pass). Not redeployed — build + restart to activate.
2026-07-16 — Shell action contract (drawer + OS menu) + BYOK add-provider (DONE)
Closed the gap the Apple mock flagged: feature slices now feed the shell's
menu/drawer format, and BYOK matches models-rahmanef-com's "add provider". Built
from a 3-probe audit → DRAWER-MENU-BYOK-PLAN.md. tsc + lint + vitest (299) green;
behaviorally verified on an isolated :4011 dev server (prod never touched).
- Shell action contract — one bus, both surfaces. The AI-Inspector bus already
publishes live per-app
actions(all 14 apps). Surfaced them as (a) the desktop menu-bar app menu (menu-bar.tsxreadsuseInspectorInfo(focusedId).actions) and (b) a mobile in-app bottom-sheet drawer — a trailing "•••" in the iOS (mobile-shell.tsx) + Android (android-shell.tsx) app headers opens the newAppActionsSheet(shadcn Sheet side=bottom). No per-slice edits, no new bus. Did NOT rebuild to the mock'sprepare(ctx)→osmerge model. Verified: iOS/Android "•••" → New folder/Refresh/Empty Trash for Files; desktop Files menu lists the same. - BYOK add-provider — custom endpoint + validate + list/delete. Streaming already
consumed
resolved.baseUrl+protocol; added the storage+UI:OsConfig.customProviders(lib/config/store.ts), SSRF guard (lib/host/ssrf.ts+ test), aprotocoloverride onresolveModel(lib/models/resolve.js),/api/configGET-list / POST-custom / DELETE,/api/models/test(1-token validation), and the Settings AI panel: custom-provider form (custom-provider-form.tsx+custom-provider-config.ts+ test, ported from models-rahmanef-com), connected-provider list with delete (provider-list.tsx), Test badge. OAuth deferred (Phase D — big lift; the mock's "Sign in with OpenAI" is Codex device-code, not the platform API). - Guards: iOS/Android edits live in their single-mount shells; the desktop menu addition is
additive (empty actions → nothing renders); a null custom conn keeps built-ins registry-pinned
→ macOS/Windows/Dashboard byte-unchanged. Not redeployed —
pnpm build+sudo systemctl restart mso.serviceto activate.
34 older entries (2026-05-29 → 2026-06-15) were trimmed on 2026-08-10 to keep
this file readable as the source of truth it claims to be. Nothing referenced them
by line, and they are one command away: git show 421ab7f:docs/PROGRESS.md.
2026-08-20 — ChatGPT generated-file → VPS bridge (DONE)
MCP now exposes fs_upload_file with _meta["openai/fileParams"], so ChatGPT can generate or receive an image first and then transfer the exact file bytes into an existing bounded VPS directory. The server accepts only temporary HTTPS OpenAI file references, caps imports at 20 MiB, validates image MIME types, inherits the existing write-root and credential denylist through uploadInto, audits as fs.upload, and returns byte count plus SHA-256 without persisting the temporary download URL.
2026-09-05 — Session-scoped screenshot evidence
Screenshot evidence previously lived in unrelated scratch directories or only in MCP image responses. Added one derived session path policy, a private manifest, explicit image/report reads, and bounded registration/retention. Exec receives non-secret session directories; original bytes remain private and session responses compute paths instead of persisting absolute homes. Cleanup is lazy, lease-aware and fail-closed for unknown files; it does not run during builds or remove durable history. User/client isolation, retry de-duplication and existing integration changes are preserved. See SESSION-ARTIFACTS.md for limits and verification scope.
2026-09-08 — Self-hosted Convex doctor endpoint reconciliation
- Self-hosted Convex credential verification now checks
/api/check_admin_keywith the configured admin key, while retaining the existing SSRF safeguards, loopback-only HTTP exception, redirect refusal, and redacted failure behavior.
2026-09-06 — Convex Cloud custom-domain control
- Added a native
convex-cloudCLI credential import that reads only~/.convex/config.json, refuses symlink/non-owner inputs, hardens the local credential directory/file to0700/0600, validates the token before saving, and never returns the credential. - Added bounded exact-connection operations for listing/ensuring Convex custom domains and reading/updating canonical
convexCloud/convexSiteURLs. Canonical operations mint a scoped short-lived deploy key and revoke it infinally; custom canonical URLs must already be registered and verified. - The operations stay behind
integration_execute/integration_manage; no generic Convex HTTP escape hatch and no new global MCP tool were added.
2026-09-06 — Dokploy deployment diagnostics + safe public Git recovery
- Added bounded deployment-history and redacted deployment-log reads for Dokploy applications, using the official
deployment.all/deployment.readLogsAPIs. - Added
dokploy.git.recover: for an application currently configured as a Dokploy GitHub source, derive a public HTTPS GitHub URL only from its existing validated owner/repository metadata, preserve branch/build path/watch paths/submodule settings, verify the source became genericgit, then queue one redeploy. No arbitrary Git/SSH URL input is accepted. - Internal provider diagnostics remain out of the compact MCP schema; only the bounded deployment list/log and recovery operations are exposed.
2026-09-06 — Convex environment presence checks
- Added
convex.env.presence, a bounded deployment-admin read that accepts 1–32 exact environment variable names and returns only boolean presence for those requested names. - The operation creates a short-lived deploy key scoped only to
deployment:env:view, always revokes it, never returns environment values, and never exposes unrequested environment-variable names. - Used the presence-only check to confirm CareerPack production has both
AUTH_GOOGLE_IDandAUTH_GOOGLE_SECRET; therefore its customconvexSiteremains non-canonical until the Google OAuth redirect URI is migrated.
2026-09-06 — Private DOKU MCP connections
- Added
dokuas a native named integration with one deliberately bounded auth method: DOKU MCP. Payment REST HMAC credentials are not accepted by this provider until MSO has a non-mutating official verification contract for them. - DOKU MCP setup stores Client ID/API Key only through the private setup flow, pins environment to
sandbox|production, derives only DOKU's official MCP endpoints, and verifies credentials with a read-only JSON-RPCinitializerequest before saving. - Portable connection mapping supports
DOKU_MCP_CLIENT_ID,DOKU_MCP_API_KEY, andDOKU_MCP_ENV; credential values remain redacted from summaries and tool output.
2026-09-06 — DOKU Payment + MCP credential separation
- Expanded the native
dokuintegration from MCP-only to two explicit methods: Payment REST (Payment Client ID+ HMACPayment Secret Key) and MCP (MCP Client ID+MCP API Key). The methods cannot silently substitute for each other. - Payment credential verification uses a signed, read-only synthetic Check Status request against the fixed official sandbox/production endpoint. Only a verified
Transaction Not Foundresponse is accepted;Invalid Merchant404 remains fail-closed. - MCP credential verification remains a fixed-endpoint MCP
initializerequest. DOKU credentials stay in MSO's owner-only integration store and are never copied into project MCP JSON, Baton notes, RR, or chat.
2026-09-06 — Bounded Dokploy manual deploy
- Added
dokploy.application.deploy, an exact-application bounded operation through a selected named Dokploy connection. It queues only/application.deployfor a validated application ID and returns no provider credentials. - This replaces project-specific redeploy helpers that read a loose Dokploy API key from shell environment when an auto-deploy webhook is missed.
2026-09-07 — Integrations workbench
- The browser route and embedded MCP Page now share a responsive service rail, real connection-readiness summary, compact account cards, and contextual setup/actions. Setup guides and maintenance controls use progressive disclosure; account switching remains explicit.
- Integration snapshots no longer repeat the complete provider catalog, which is already embedded in the shared manager. The explicit catalog query remains available; compact snapshots prevent bounded MCP responses from truncating the Page.
- Validation: 26 browser assertions at 320/390/768/1440/1920 px in light/dark themes, account isolation, service search, setup focus, auto identifiers and Verify feedback; full verify passes.
2026-10-22 — Composio session MCP credential
POST /api/v3.1/tool_router/sessionhas nomcprequest field and its 201 response carriesmcp.urlwithout headers, so a stored session previously had no credential and could never be called.mcpHeadersis now the exact headercomposioAuthHeaderreturned for the credential that authenticated that same create call (x-api-keyproject,x-user-api-keyuser,x-org-api-keyorg), matchingdocs/sessions-via-mcp. A future responsemcp.headersstill wins verbatim.- The session MCP URL host is validated against the existing Composio redirect allowlist plus
app.composio.dev(the spec example host); any other host fails closed withinvalid_composio_mcp_host. Header values stay server-side: the route still returns onlymcpUrl.