Skip to content

armgit / mso

Public Imported from GitHub
0

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

585 KB
Raw Blame

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.json predates several dependency bumps; re-measure on an idle host.
  • Local branches from other tracks remain under ~/.cache/mso-worktrees and 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

  1. A parallel track moved this session's worktree to main twice mid-run. Commits appeared lost; recovered from the reflog, then all further work moved to a dedicated worktree with a symlinked node_modules.
  2. /tmp filled to 78% with three out-of-tree builds. The release E2E reported it as verification failed during mandatory release E2E, which reads exactly like a code failure. Cleaned; re-ran; passed.
  3. 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.
  4. git stash pop after git checkout main silently dropped a change that the merge had already taken; gen-changelog --check caught 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.json predates 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 + coverage failed 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 build failed with "verification failed during mandatory release E2E" because verify-build.sh copies the tree into /tmp per run, and two copies exhausted the 9.8 GB tmpfs. The real error was cp: 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-estree needs 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

  1. Worked on someone else's branch. The working tree was on fix/tui-pty-bugs, not main, and three commits landed there. Recovered: that branch was reset to its original 0425ec8c (its TUI work was already identical to origin/main #201, so nothing was lost) and the commits moved to perf/eager-graph-artwork rebased onto origin/main.
  2. A git add in a shared working tree swept six throwaway probe scripts into another track's commit (80adb801). Removed in 860b4c07. The lesson is not "commit faster" — it is that a second track committing in the same tree will add whatever is lying around.
  3. /tmp filled to 99 % with three out-of-tree builds at 2.3 GB each. production build failed with Failed to write upload in the 200 MiB E2E, which looks exactly like a code bug. The pristine-HEAD control failed identically until /tmp was cleaned. The handover warned about this one.
  4. Running the gitleaks container with -v "$PWD:/repo" left 67 files in .git owned by root, because it is a partial clone (blob:none) and git inside the container promisor-fetched and rewrote refs. sudo needs a password here. Fixed with docker run --rm -v "$PWD/.git:/g" alpine chown -R 1000:1000 /g; git fsck --connectivity-only clean 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 is 7c4569ae (7 commits, CI green on Verify, Native host macOS + Windows, CodeQL, Dependency Review); local is rebased further onto origin/main and not pushed, so the PR still reports the older head and stays mergeable_state: dirty against a main that has moved. Pushing it is a force-push and needs the owner's explicit go-ahead.
  • perf-baseline.json was regenerated after all (commit ba13b20b), 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.sh built an unstartable image (exec: /usr/bin/node: permission denied) from three compounded issues: install preserved the host uid 1000 ownership (fixed by tarring with --owner=0 --group=0), umask 077 created /usr and /usr/bin as drwx------ which failed under container --cap-drop ALL lacking CAP_DAC_OVERRIDE (fixed by normalizing directory modes to 0755), and a blanket file chmod 0644 cleared the executable bit on ld-linux and dynamic libraries (fixed by restricting permissions normalization to directories only, preserving 0755 on binaries).
  • lib/host/fs-zip.test.ts assumed os.tmpdir() was private and counted os-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 coverage went 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 tripped nonMcpMcpImports (7 / max 0). They moved back to app/api/v1/workflows/ as route-read.ts and friends, following the pattern a2a already used. A ratchet, not a reviewer, found a real boundary violation.
  • Moving bodies into lib/ carried import { NextResponse } from "next/server" with them, so lib next/* went 0 → 23 immediately after Phase 2 had just achieved 0. All 23 were converted to the web-standard Response; 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-shell is macos on desktop and ios on mobile; a hardcoded macos made 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 exact orca_server_ready schema-1 tag, health.buildVersion 1.4.230 (an artifactVersion cannot override it), pinned Node 24.21.0 ABI 137, live terminal daemon, ws loopback bound endpoint on the managed port, exact configured wss advertised endpoint, and explicit runtime pairing.
  • Mandatory identity receipt + process identity (lib/managed-apps/orca-process-identity.ts): runtime-identity.json is 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, opens O_NOFOLLOW, bounds size before reading, re-checks identity, and never touches the owner's personal ~/.orca. Invalid ORCA_HOME fails 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; arbitrary webClientUrl is never trusted.
  • Session route returns no-store on 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 real Response/AbortController.
  • Honest docs: docs/ORCA-INTEGRATION.md corrected and classified in docs/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: serviceworker rejection 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/orca or ORCA_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 with Cache-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 when installBackends is 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-orca with commandProvesInstall: false, service mso-orca.service, no generic container detection, default port 6769, health path /web-index.html, and state dir orca.
  • 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 verify completed 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.ts require a real accessible Docker daemon and the existing mso-forge-sandbox:node22-v1 fixture image. No Docker executable, daemon socket or remote Docker host was available. After Docker is available, use bash 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.ts expects 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.ts copies a fixture checkout that lacks the new scripts/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.sh finalizes through a systemd-run --user transient unit, and that unit's default PATH (/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:…) does not contain node on this box (node lives in ~/.local/bin and ~/.hermes/tools/…). scripts/mso-gateway runtime-stop therefore exits instantly with mso gateway: missing dependency: node, before it can even inspect runtime ownership.
  • The same finalizer (scripts/self-update.sh) restarts by signalling an active mso.service MainPID that has Restart=always. This box has no mso.service at 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, verified workflow_finish(success=true), user-facing Workflow create/save/restore (including session→draft), and Organization flow_node_upsert. Workflow/node domain receipts are bounded metadata only; graph configs, node notes, variable values and credentials are excluded.

  • Historical Gitleaks closeout: the two remaining findings were exact older fingerprints of deterministic SC-sync test fixtures. Added only those exact fingerprints to .gitleaksignore; a full 820-commit Gitleaks history scan now reports no leaks.

  • Replaced terminal/A2A first-12k head truncation with a frozen stable-core + query-relevant JIT memory projection. Defaults are 6k core / 8k JIT characters and are configurable without changing the durable typed-memory ledger.

  • Added deterministic bilingual/synonym normalization for bounded memory retrieval. The calibration improves from 4/6 to 6/6 lexical cases; the existing local semantic candidate stays 3/6, so vector memory remains blocked rather than adding complexity without recall benefit.

  • workflow_start compact structured output now carries selected agent/project memory plus the maturity-aware recipe plan, fixing the ChatGPT wrapper path that previously exposed only progress fields.

  • Learned recipes preserve prior intent phrasings as aliases. Telemetry now distinguishes recommendation from observed tool-route match/divergence instead of treating selection as proof of reuse.

  • Exact identical ordinary current replace writes now resolve to deterministic NOOP instead of growing redundant ledger history; explicit temporal/provenance timestamps and parallel claim evidence remain append-only. Retrieved memory keeps stable refs for audit, but retrieval alone is never labeled causal use.

  • Prompt projection strips hidden/bidi controls, neutralizes reserved memory-boundary tags and redacts secret-shaped material before model injection. Persistent memory remains evidence/context, never authorization.

  • Research boundary: adopts provider-neutral control-plane lessons from DeepSeek-V4.1-Flash (2609.19969), Hermes bounded frozen memory/on-demand recall, LongMemEval-V2 compact evidence gathering, and structured/evidence-aware ideas from Memory-R1, Hindsight, Mem0 and A-MEM. It does not import vendor model/KV code, require embeddings/graph storage, or weaken scope/promotion gates.

  • New/updated gates: memory context unit coverage, compact workflow-start projection coverage, recipe recommendation-vs-route-match regression, 6/6 lexical retrieval, 4/4 stable-core/JIT, 3/3 two-hop, existing 8/8 lifecycle and typed-memory deterministic suites.

2026-09-19 — Separate ChatGPT native-app context from plugin staging

Post-refresh acceptance proved that ChatGPT has the latest MSO tool schema but the currently selected orchestration path still returns render_mso_block as decoded structured data rather than mounting the MCP App. The server-side descriptor/resource/result contracts remain unchanged: the new evidence is at the host/package boundary. The owner-private OpenAI package was validly staged with a redacted registered-app binding, but this machine had neither a personal marketplace declaration nor a cached MSO plugin install. Staging on the VPS therefore did not install, publish, refresh, or select anything in ChatGPT.

Added plugin:doctor-private plus a post-stage doctor that verifies private modes, the .app.json link and canonical binding while never printing the binding value, and reports local marketplace/cache state separately. The ChatGPT plugin reference now makes the acceptance boundary explicit: direct registered-app/app-context or an actually installed package is required for native UI verification; a generic function/Code Mode wrapper returning the inner object is not visual MCP Apps evidence. No MCP UI HTML, CSP, resource URI, OAuth behavior, tool scope, or personal App ID changed.

2026-09-19 — Make compact MCP Apps standards-first and align plugin bindings with references

A live ChatGPT test showed MSO render tools returning valid structured data without a visible component in the current nested connector/orchestration path. Server-side audit confirmed Page already implements the MCP Apps ui/* lifecycle, while compact List/Block still depended on ChatGPT-specific follow-up APIs for part of their interaction path. List v2 and Block v4 now share a standards-first bridge: ui/initialize, initialized/tool-result notifications, ui/message, host-context updates and teardown, with window.openai retained only as a capability-detected compatibility fallback. Old List v1 and Block v3 remain non-advertised read aliases so cached clients fail safely. Browser E2E now exercises the real compact postMessage lifecycle.

The plugin/package audit also compared MSO against the saved Shopify, GitHub, Data Analytics, OpenAI Templates, Plugin Management, Google, Figma, Notion, Convex and Sites references. The .app.json validator now matches the documented canonical ID families, accepts optional/required booleans and snake/kebab aliases used by the references, and rejects persisted plugin_... URL identifiers. The linker normalizes a copied plugin_asdk_app_... identifier to canonical asdk_app_... before writing. All 18 saved reference manifests validate, and all 14 official MSO skills still pass their contract + agents/openai.yaml checks. No app ID is invented for MSO: the package mapping remains empty until an exact registered identity is supplied.

2026-09-19 — Derive an isolated Camoufox sibling instead of assuming the managed-app namespace

Camoufox viewer authentication no longer needs the cockpit Domain cookie, so tying its hostname to {id}.mso.example.com unnecessarily inherited deeper wildcard-certificate and cookie-scope constraints. The viewer now prefers an explicit CAMOUFOX_VIEWER_ORIGIN, otherwise derives a sibling outside the configured cookie namespace (mso.example.com → camoufox.example.com) or from a host-only cockpit origin. Overrides that share the cockpit host/cookie Domain, contain credentials, paths, queries, fragments or non-default ports fail closed. A broad two-label Domain has no safely inferable sibling and requires an explicit separate viewer origin. Managed-app host templates remain independent. A deployment shaped as mso.operator.test therefore resolves to camoufox.operator.test without any maintainer-specific source literal.

2026-09-19 — Probe the cache-isolated Camoufox viewer entry path

The viewer cache boundary moved noVNC under /_mso-camoufox, while the authenticated transport diagnostic still probed legacy /vnc.html with redirects forbidden. A healthy viewer therefore returned 307 and the Browser UI rejected it before requesting its viewer ticket. The public viewer prefix and entry path now live in one lightweight contract used by the gate, session metadata and server-side transport probe. The probe still sends no cockpit credentials, follows no redirects, requires HTTPS and keeps the existing SSRF/TLS checks. Targeted regressions verify the exact namespaced HEAD request, viewer gate, service route and client connection behavior.

2026-09-19 — Separate AI connection from selection and harden public updates

  • OpenAI/Codex OAuth now connects credentials without changing Alfa's active provider/model unless the owner explicitly chooses Connect & use. Existing Google Gemini and other BYOK connections remain stored and selectable.
  • Alfa Cockpit can switch provider + model only among already-connected providers; credential creation/copy stays in Settings. A release browser journey proves Google Gemini → Codex → Google Gemini while both credentials remain connected.
  • Canonical MSO Git remotes are recognized across HTTPS/SSH forms and canonical SSH is normalized to the public HTTPS repository before install/update fetches. Git fetch/clone is non-interactive by default; explicit forks/private/custom MSO_REPO origins are never rewritten and retain their own origin/main authority.
  • Focused provider/updater regressions, full TypeScript/ESLint, production build and release E2E pass on the isolated candidate.

2026-09-19 — Bind Convex snapshot authorization to the opened descriptor

The prior staging hardening consumed bytes through one open descriptor but still authorized the caller path before opening it. O_NOFOLLOW protects only the final component, so a parent-path rename/symlink swap could otherwise redirect the later open outside the reviewed read root. Snapshot staging now re-runs resolveReadable() immediately after open, requires the caller-visible canonical path to be unchanged, and compares the named file's dev/ino to the descriptor fstat. The same identity check runs again after the private descriptor-only copy. An adversarial regression replaces the path after open() and proves the import is rejected rather than staging the old descriptor bytes under a now-different pathname.

2026-09-19 — Pin Convex snapshot imports to validated bytes

The security inventory exposed CodeQL alert #139: snapshot metadata was checked by pathname, then the same pathname was reopened for hashing and later passed to the Convex CLI. Snapshot validation now opens the source once, performs ownership/size/ ZIP checks and hashing through that descriptor, copies those exact bytes into a private 0700/0600 staging location, verifies the descriptor did not change during the copy, and imports only the staged file. The private copy is removed in a final cleanup path, while result metadata continues to identify the caller's original source path. Regression coverage changes the source after validation and proves the CLI still receives the validated staged bytes.

2026-09-19 — Keep strict Semgrep coverage complete on the macOS installer

Hosted Semgrep reported zero findings but exited 3 under --strict because its Bash parser partially parsed the heredoc nested inside persist_path in scripts/install-macos.sh. The installer now emits the exact same shell-profile block with literal printf arguments instead of that heredoc. --strict and --error remain enabled, the public dispatcher checksum is updated, bash -n stays clean and platform/install regressions pass. This fixes parser coverage rather than suppressing or downgrading the security scanner.

2026-09-18 — Close graph routing review without changing executable topology

PR review exposed four presentation/runtime issues: clear short facing ports could be mislabeled as overlaps, controlled parent selection could be ignored for existing nodes, each routed edge recomputed against the whole obstacle set during drag, and compact fitting could center arbitrary storage-order nodes instead of workflow triggers. The shared route scene now clamps/direct-routes short clear links, caches route geometry across unrelated movement, and is owned at the canvas boundary. Endpoint sibling ranks are built once per scene instead of rebuilding/sorting an adjacency union for every edge; after warm-up, a 25-run 200-node/400-edge synthetic scene build measured about 0.48 ms median on this host, while repeated unrelated movement reused all 400 cached routes. Controlled selection changes win while transient box/ctrl selections survive data-only updates. Compact focus derives from manual/schedule/webhook or semantic session roots and maps collapsed trigger members to their visible custom-group proxy. Grouping remains presentation metadata; stored nodes, handles, edges and execution semantics are unchanged.

2026-09-18 — Selected custom nodes and visible connector routing

  • Complete selection-based named grouping in Workflow and Organization project canvases. Collapse/expand/ungroup retain original executable nodes, ports and edges; grouping is bounded, validated metadata in the existing private stores.
  • Preserve multi-selection and atomic group/multi-node movement; prune group membership only on explicit member deletion. Extend existing function-calling and CLI actions rather than inventing another store.
  • Replace unconditional smoothstep connectors with shared bounded orthogonal routing against measured cards, directional markers, crossing halos and selected-route emphasis. Impossible overlapping-card paths are visibly marked rather than silently claimed safe.
  • Verification is performed against synthetic stores and the real production build; private operator graph content is never embedded in source.

2026-09-18 — Include the remaining reviewed public asset variants

The first exact-main run of the path-scoped validator correctly failed because the live asset graph also contains content-hashed CSS chunks and Next's versioned SVG app icon. The raw report showed rule 10050 only on public cacheable assets. Header checks confirmed CSS is public/immutable for one year and the icon is public for one week. Extend the validator narrowly to CSS chunks and only the exact ?icon..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 projectFlow to 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.yaml bundles for all 13 official skills, a portable root .codex-plugin/plugin.json, local artifact validators, compact contract-aware skill discovery, and full-MCP mso/actionContract lifecycle 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 /mcp app 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_file is 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_file now exposes owner-bound ephemeral mso-file:///… resources; resources/read returns 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/openExternal after 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_capabilities and project_function_call, requires an exact top-level string constraint for every allowlisted tool, filters initialize / tools/list, and re-checks both the tool allowlist and argument constraints at tools/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/main and reports ahead and behind separately. A normal update is refused when local main is ahead or diverged, so unpushed work cannot be silently deployed or overwritten; --rebuild remains 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 --check is 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 noUnusedLocals and noUnusedParameters now 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.2 keeps 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:features runs 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 from package.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 / toolset 2026.09.04.7 moves the two canonical ChatGPT resources to ui://mso/block-v2.html and ui://mso/page-v2.html so hosts do not reuse the old purple CSS cache key. Block and Page now share one visual-token source aligned with rahmanef.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 through window.openai.theme with 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 / toolset 2026.09.04.6 removes the automatic UI binding from workflow_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.html through render_mso_block for compact validation/action/CRUD input-output, and ui://mso/page-v1.html through render_mso_page for 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, while workflow_status and render_mso_surface remain 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 --json at 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. See scripts/audit.mjs.

  • MCP Apps CSP metadata dedup / Surface v5 (2026-09-04): MCP server 1.9.4 / toolset 2026.09.04.5 moves all standard widget CSP fields to the preferred _meta.ui.csp surface and leaves legacy openai/widgetCSP with only redirect_domains for Open in MSO. Workflow/Surface resources are cache-busted to workflow-progress-v3 and surface-v5; the reviewed Play Together iframe remains exact-origin under /embed, so one external-iframe review advisory is expected from ui.csp.frameDomains. Scanner-facing Surface metadata explicitly names /apps/play-together and has a regression guard against cross-scope app examples.

  • MCP Apps presentation unification / Surface v4 (2026-09-04): MCP server 1.9.3 / toolset 2026.09.04.4 retires the specialized project-status-v2, project-diff-v2, and vps-status-v2 resources. project_get, project_diff, and vps_status are pure data tools again; ui://mso/surface-v4.html is the only general-purpose UI and uses the portable MCP Apps tools/call bridge for native monitor/project/diff views. workflow-progress-v2 remains intentionally separate for live workflow polling. Play Together keeps the exact game.example.com/embed frame 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 older mso-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 / toolset 2026.09.04.3 upgrades ui://mso/surface-v3.html so Play Together can render live inside ChatGPT without relaxing the whole app. The Surface allowlists only https://game.example.com, starts it at /embed, revalidates the exact origin plus /embed path 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 exact mso-ui.example.com ancestor 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 / toolset 2026.09.04.2 removes accidental cross-project catalog entries from Fresh 3. ui://mso/surface-v2.html keeps the generic secure Surface architecture but its current VPSKU app catalog contains only Play Together (https://game.example.com) as a remote target because that app currently sends frame-ancestors 'self'. The Surface CSP therefore has no third-party frameDomains at 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 MSO no longer lands on an idle desktop. Workflow/VPS/project/diff cards target /assistant/mcp, /monitor, /files, and /code; the shell also recognizes ChatGPT's root redirectUrl=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 build in the active service checkout replaced .next while the old Next process still served its boot-time manifest, making all 19 root-referenced chunks disappear and one observed JS request return 500 text/plain. Production was recovered through mso deploy; shell + Settings then passed real authenticated Playwright on desktop/mobile with zero failed requests/console errors. bun run build is now a fail-closed wrapper that holds the checkout exclusion and refuses a same-checkout live runtime; mso build remains 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 recursive fs_mkdir now 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>.json files (<=400 records / 768 KiB each) under 0700 directories / 0600 files. 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 forward supersedes edges 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:lifecycle is 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-1 could be displaced by substring matches like Runtime-10 before the result limit. Deterministic scoring now prioritizes exact phrases/tokens and keeps bounded alphabetic-prefix stemming. Existing bench:memory stays 8/8 / 100%.
  • Vector and graph complexity remain evidence-blocked: realistic retrieval calibration is 4/6 lexical, with objective misses only for IDE↔editor synonym and Indonesian kantor↔English office. P10D compares the existing local mso-local-hybrid-v1 semantic 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:calibration remains 6/6 and future-scheduled claims still cannot resurrect after forget. 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 / toolset 2026.09.03.7 bumps all four UI resources to v2 and makes Open in MSO self-diagnosing: official openExternal + 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_forget previously 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 d249da4 passed 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. Existing bench:memory stayed 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 / toolset 2026.09.03.6 keeps the 62-action Fresh 3 surface unchanged while closing the post-refresh metadata gaps. Every ChatGPT action now advertises outputSchema; 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 origin https://mso-ui.example.com (Traefik config in ops/traefik/mso-ui.yml), and the OpenAI/MCP skills extension publishes five official, digest-verified claude-skills/ snapshots through skills/list, skills/get, and resources/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 / toolset 2026.09.03.5 restores 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-only workflow_status) at 57,853 descriptor bytes (~14.5k rough tokens), while the full model/operator catalog grows to 85 tools. New Lovable-inspired surfaces add project_get, Git history/diff, .mso/KNOWLEDGE.md, safe connection inventory, private project_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.3 stops claiming the stateless 2026-07-28 protocol while serving the legacy initialize/session wire shape. The supported ceiling is deliberately 2025-06-18 (matching the known-good CareerPack ChatGPT connector); a modern HTTP probe receives a 400 and can fall back to initialize. server/discover is no longer aliased to the legacy initialize payload. Browser CORS also permits Mcp-Method/Mcp-Name so a standards-aware probe can reach the server and receive the fallback signal. Toolset stays 2026.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-terra runs from source 51ae31f produced 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=5 remains descriptive; no CI/p-value or universal reliability claim is made.
  • Dedicated repeated-prefix cache calibration: new bench:cache-calibration keeps 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-terra runs from source 5bd5788 produced 18/18 task + 18/18 scenario-policy for both MSO and Hermes, with 2/2 perfect runs each. The prior P6 Hermes multi-read miss did not recur (2/2 here 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.com and returned OPTIONS without usable CORS headers. MCP server 1.7.2 now permits the exact ChatGPT browser origins only against the configured public MSO origin, keeps arbitrary/loopback-origin requests denied, adds explicit /mcp preflight headers, and adds public CORS to OAuth discovery/DCR. Toolset stays 2026.09.03.4 because no tool descriptor changed.
  • Fresh app means fresh OAuth client: POST /oauth/register now mints a distinct RFC 7591 client id for every registration. Redirect URIs are client metadata, not identity; two ChatGPT dev apps sharing the same chatgpt.com callback 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-chatgpt client 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 at read_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 to 2026.09.03.4; live acceptance must include Inspector tools/list --strict with 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_tools and project_mcp_call. .mcp.json stays private; project_capabilities exposes 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 MSO tools/list.
  • OAuth/transport refresh hardening: new OAuth grants bind resource=<origin>/mcp, return iss, issue one-hour access tokens plus rotating hashed refresh credentials, and revoke by grant family. Legacy bearers remain a migration path. Streamable HTTP validates MCP-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:corpus now adds objective repo-debug, repo-migration, and transactional rollback fixtures 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, and policyObservationScope=scenario-tree explicitly avoids whole-host sandbox claims.
  • Benchmark found and fixed RASMIC routing debt: ordinary repo debug/test instructions 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 selects exec_run, and repo-first debug/migrate/rollback requests enter repo-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_start could 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 one workflow_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-read with intact scenario state but an incorrect exact aggregate. An alternating-order follow-up repeated multi-read three 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-total semantics; Anthropic keeps its separate cache categories and leaves absent fields absent. Agent sessions start with apiCalls: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 uses explicit-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 stay opaque-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) and policyObservationScope=scenario-tree prevents 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, so tokenSemanticsComparable=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 source none; 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 to read_pipeline. Initial security diagnostic: 3 tools / 14,934 reported tokens / 16,072 ms. Final matched-provider corpus: 1 fs_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. Final multi-read uses one read_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_inbox now accepts optional wait_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_ms preserves the previous immediate inbox behavior.
  • Receivable MCP presence: the MCP dispatcher keeps local_agent_inbox sessions idle rather than marking the receive call busy, allowing local_agent_message_send / local_agent_reply to publish directly to that foreground receiver. Other tool calls retain normal busy → idle presence.
  • 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 invokes local_agent_request or any spawned durable-session worker.
  • Toolset: upstream P3 already added read_pipeline; this schema-only Local Agent update therefore advances the catalog to 2026.09.03.2 while keeping 71 transport tools = 70 model/operator tools (34 read / 24 write / 12 exec) + app-only workflow_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 causing mso update to 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 child workflow_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 read scope even when the parent bearer is exec. 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:pipeline preserves 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.mjs now derives tool modules from the canonical lib/mcp/tools.ts composition and fails on orphan tools-*.ts modules, so adding a new tool module cannot silently escape MCP/ChatGPT/connectors documentation. Toolset advances to 2026.09.03.1: 71 transport tools = 70 model/operator tools (34 read / 24 write / 12 exec) + app-only workflow_status. The docs checker follows the recursive tools-* import closure from lib/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 recoverable not_started | completed | uncertain mutation 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, toolset 2026.09.02.7, 67 transport tools = 66 model/operator tools (32 read / 22 write / 12 exec) + app-only workflow_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.mjs now verifies the MCP marker in architecture/operator docs and exact scope membership in docs/MCP.md and docs/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-width Input · @milo divider separates transcript from editing state; permission moves to the dynamic footer as mode 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 Assistant section lazily on the first text delta, tool/subagent execution opens Agent work, and Local Agent send/receive/inbox output uses Local 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 Error section. The turn journal distinguishes not_started, completed, and uncertain mutation 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 permissionPrompt and renderStatusBar helpers 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 name separate from its longer title. Fresh sessions allocate familiar easy-to-type names such as milo, luna, or nara; 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. Internal agent-a presence 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 from consumerConnected / consumerCount, so idle no longer implies an SSE consumer exists.
  • Bounded request observability: added read-scope local_agent_request_wait, returning replied, target_offline, consumer_absent, or timeout in a bounded 0–30s foreground call without resend/background polling. The testing-handoff local_agent_request is 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 / deny decision is mandatory. Auto-write/YOLO still compute exact payload binding while skipping only the human prompt.
  • Subagent testing capacity: OS_SUBAGENT_MAX_TURNS defaults 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, and requiresUserRelay. Legacy sends remain notify-only; local_agent_reply inherits routing/correlation/relay policy from one exact inbox request.
  • Deterministic async relay: correlated replies are matched against a durable source local_request ledger and become a synthetic assistant relay without another model turn. Notify-only/stale/mismatched/duplicate events never create extra assistant answers.
  • Processing semantics: SSE delivered no 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: /spawn and agent_subagent_run now 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_*, and a2a_* are unavailable inside workers. Legacy mso a2a spawn remains 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, and ended have 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. Manual agent_session_rename//title names 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/task payloads persist privately before notification. Idle delivery can be delivered/accepted, busy targets are queued, and known expired/ended targets return target_offline while retaining the message for a later receiver.
  • TUI: /agents, /message, local /delegate, and /inbox use the native layer. Incoming events redraw above an active composer without losing draft input, persist as role agent, 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: /restart now uses process replacement (execve) instead of spawnSync. Repeated refreshes no longer leave prior Agent processes blocked behind their children.
  • Wrapper boundary: interactive mso agent now execs 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 latest bin/mso and Agent modules while loading the exact same durable session id through a restart-only path; normal /resume continuation semantics remain unchanged.
  • Fail closed: runtimes without process replacement support refuse /restart rather than silently falling back to a nesting child process. Node 22 on the supported MSO runtime provides process.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 | exec delegated 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 taskId as 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 0600 storage 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: SendStreamingMessage and SubscribeToTask use SSE; observer disconnect does not cancel execution. CancelTask remains the explicit cancellation boundary.
  • Ingress: /.well-known/agent-card.json and /a2a/v1 are machine-protocol surfaces with no document CSP/nonce or browser-cookie CSRF gate; /api/v1/a2a remains owner-cookie + CSRF protected. Public inbound serving is enabled when an explicit HTTPS OS_PUBLIC_ORIGIN is configured; OS_A2A_INBOUND_ENABLED=0 disables it. Same-host exact-loopback A2A is enabled by default and can be disabled with OS_A2A_ALLOW_LOOPBACK=0.
  • CLI: mso a2a state, stream, auth ..., and inbound ... 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 mso now launches MSO Agent; mso agent/mso chat are explicit aliases and mso model connects 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/assistant backend;
  • the terminal discovers the canonical MCP catalog through an Owner-only /api/v1/agent-tools bridge. 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 word configured for secret fields, and no raw secret enters model/MCP arguments;
  • mso provider set dokploy|cloudflare|hostinger uses 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:true with one name + type row), so unrelated zone rows never enter the PUT payload; ambiguity/conflicts remain refused and the mutation stays approval-gated;
  • official mso-project-deploy skill 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 update now 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/host architecture. For the current implementation start at docs/README.md and docs/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 download on 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 one saveAs() 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' joinPath did not strip a trailing slash, the Code editor's did, Preview's sibling lookup carried a third regex. These strings become the path= of an /api/v1/fs request, so /a//b is a different path to a host that resolves it literally. One lib/path.ts now — lib/, not appshell, because the framework may not depend on mso's lib and this is the same universal category as cn.
  • Files' icon + colour tables had drifted from Preview's format table: a .heic drew a generic grey icon and a .m4v an uncoloured one, because the local sets predated the viewer's. Both read kindForName now; 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/html there 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 over requireSession(), and the parameter invites the reading that the request is checked (it is not; proxy.ts owns 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 .next already deleted and nothing to restart into. startUpdate() now hands the job to the owner's TRANSIENT user unit via systemd-run --user; that separate cgroup survives while the script signals the same-uid service PID and lets Restart=always bring MSO back. The original 0.2.0 implementation used a system transient unit through sudo -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.sh is run by a person who is watching; this is run by an operator who pressed a button and walked away. scripts/verify-build.sh proves 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 .next to 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 pure blockingReason() so they happen before anything is touched, and sys.update is 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/html there would make any host file an active document on the cockpit's origin, which is the same hazard the SVG sandbox header 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="" srcdoc frame: 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 none on 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.list of 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 .md or .csv double-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.ts recorded ok: true for anything that did not throw. runCommand REFUSES a destructive command by returning code 126 — so a blocked rm -rf / landed in the trail as a successful exec.run, exec.blocked could 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, with detail: exit N it 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/service had 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 is unknown.

Security, in things that were already live:

  • /api/skills followed symlinks with no check, outside the fs jail and outside the credential denylist, so a symlinked SKILL.md served its target from anywhere. Now the resolved path must still be named SKILL.md. Containment could not be the rule — every ~/.claude/skills entry links into claude-skills/, deliberately not a scanned root.
  • Recalled memories were spliced into the SYSTEM prompt unframed, and memory.remember runs 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.js and image-editor.sh fell back to a device id committed in a public repo, and audit.js printed 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/prefs was 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.tsx caught the rejection and dropped it — which also disabled the recovery its own comment named: register-sw.tsx self-heals a stale chunk from unhandledrejection, 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.
  • ResponsiveProvider allocated a fresh state object on every resize, so React's Object.is bailout could never fire — and this value is read at the shell root, so every event re-rendered the whole tree, each one paying a synchronous getComputedStyle. Now one rAF-coalesced measurement that bails when the geometry is unchanged. Mobile fires resize on 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.

  1. 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, because DesktopChrome shared a module with Surface. It moved to components/shells/macos/; all five shells now register through register-shells.tsx with lazy(). −68 KB on a phone, −42 KB on a desktop.
  2. installAlfaSources() ran at module scope, so every signed-in load pulled the host-tool catalog + its 12 run() closures + agent presets (88 KB) into the initial bundle AND fired GET /api/skills — 90 serial SKILL.md reads, 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 — see chat-composer.tsx:45, which documents the exact bug a useMemo reintroduces 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.

  1. The nonce attribute on the theme-restore inline script. Browsers blank the nonce content attribute once CSP has consumed it (anti-exfiltration), so the DOM reports nonce="" while the server HTML carried the real value. Dev build showed it verbatim: + nonce="NjA3NDAxNWIt…" / - nonce="". Fixed with suppressHydrationWarning on 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.
  2. useWidgetState's getServerSnapshot returned the live state. React uses getServerSnapshot for the first client render while hydrating, and by then the module-level state had already been read from localStorage. 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 matching load()'s no-localStorage branch.
  3. Clock could not match, for two independent reasons: it captures new Date() at SSR time and again at hydration time, and toLocaleTimeString/toLocaleDateString resolve against the server's locale during SSR and the browser's on the client. Both are named on React's own hydration-mismatch page. suppressHydrationWarning on 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 inside AppCell — 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-codes text-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 !important and 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.example was missing 6 settable vars. Reconciled against process.env in 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… grep process.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), and OS_BROWSER_*, which belong to the retired sidecar rather than this app.
  • CONTRIBUTING.md told contributors to run scripts/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 build is deliberate.
  • The /mso-browser-list skill was the worst offender. It described os-browser as the Browser app, triggered on "why doesn't the browser work" and "browser status", and told the reader to systemctl restart os-browser. All false: the Browser app is Camoufox, the unit is stopped + disabled, /api/v1/browser/* was deleted, the OS_BROWSER_URL/172.18.0.1 wiring is Dokploy-era (prod is systemd), and its .env path pointed at ~/projects/os-browser instead of ~/projects/mso/os-browser. Rewritten, and its description now explicitly routes those trigger phrases to /mso-camoufox. browser-check.js printed the same dead architecture line; fixed.
  • CLAUDE.md documented a demo that does not exist — no mso-demo.service, no /home/operator/projects/mso-demo. The NEXT_PUBLIC_OS_DEMO=1 flag 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.md listed 20 slices; there are 21 (docs was missing).
  • docs/FAQ.md still advertised "280+ vitest tests" and only two audit passes.
  • os-browser/README.md opened "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:

  1. bun audit had 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.5 and has no fixed release — only canary moved — so overrides is the only fix. sharp 0.35.3, libvips 8.17.3 → 8.18.3, /_next/image still 200. sharp 0.35 also removed its install script, so bun pm untrusted is now two entries, not three.
  2. Adding audit to verify gates nothing: sc-git's ci.js has a hardcoded STEPS = ['typecheck','lint','test','build'] and never invokes verify. The real gate had to go in .git/hooks/pre-push.
  3. "Just remove --skip build" would have been an outage on every push. ci.js builds in process.cwd(), which for the hook is mso.service's WorkingDirectory, and next build deletes everything in distDir except /^(cache|dev|lock)/ as its first act — and repeat builds rename every chunk and mint a new BUILD_ID, so already-served HTML stays broken afterwards too. --skip build is load-bearing safety. scripts/verify-build.sh builds a throwaway copy of HEAD in mktemp instead; node_modules is copied, not symlinked (Turbopack hard-fails on a symlink pointing outside the filesystem root) and .env.local is 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.local past the credential gate, and /api/v1/fs/read would then serve OS_SESSION_SECRET. Reachable on the DEFAULT roots.
  • The camoufox VNC bridge was gated only by the presence of a cookie NAMED session, so Cookie: session=x from anywhere reached a live keyboard and mouse. It is behind the same verified-session check as /api/v1/exec now.
  • x11vnc ran -nopw fronting 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:

  • 52949ec pruned unknown tool ids from saved data. mergeBuiltins lets 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 in badef71 by MIGRATING ids instead of dropping them.
  • 5e025ff cached 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 in ed8e8fd.
  • 3287f61 put the store on the eager client entry chain with an unguarded localStorage read, so a browser with site data blocked would lose the whole cockpit rather than one window — and 79938be, meant to fix it, did not: typeof localStorage ALSO 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 in c30e6e6.

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 one verifyAuth() first; actions are demo-blocked, rate-limited 12/min and audited as managed-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 logs with bearer/token/secret/password redaction.
  • Workspace modes + real feature discovery — REVERSED in a2c3882, all of this is deleted. (52cfff5, 0feaab4, 5b4b5c9) — plain | hermes | openclaw in localStorage (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 against web_dist/assets/index-*.js and /api/dashboard/plugins), OpenClaw 26 routes from app-route-paths-*.js of which 24 are offered (workboard/plugin are 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 namespaced mapp_<id>_ and pinned to the mount so the mso session never crosses; authorization / www-authenticate never 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 no content-length); route errors carry frame-ancestors or 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 narrow connect-src survive, its frame-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 second session= 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 needs allow-same-origin or 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/run with 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), so window.top is opaque — measured in Chromium 148, with a same-origin control that still breaks through. proxy.ts rewrites 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, Host authoritative over x-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-ancestors names the cockpit from deployment env only, and img-src drops its https: wildcard (the widened cookie would make new Image().src an existence oracle). The session cookie gained an optional Domain and is cleared with and without it; SameSite=Strict is unchanged and still correct because the app hosts share the registrable domain.
  • Verified live, not just unit-tested: https://hermes.mso.example.com/ and openclaw.… answer over TLS with a valid cert; /api/v1/exec/run and /api/v1/sys/stats on an app host come back as the proxy's own 401 with x-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 before pnpm build (the NEXT_PUBLIC_ one is inlined into the client bundle). Unset = single-origin mode, still the dev/demo/rollback path, with the window.top reach 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 ran systemctl 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 prints inactive with rc 4 and an empty stderr, so the first configured name always won. OpenClaw's catalog led with openclaw.service, which does not exist here, so its card read stopped with healthy: null, empty logs (-- No entries --) and 409 on every lifecycle action while its gateway served. Now systemctl [--user] show -p LoadState -p ActiveState per scope: rc ≠ 0 is "no answer" and falls through, LoadState=not-found skips the name, otherwise ActiveState decides. catalog.ts also lists openclaw-gateway.service first, though ordering no longer decides correctness. Live after the fix, both apps through the real listManagedApps(): hermes | systemd | running | healthy=true | dash=true and openclaw | systemd | running | healthy=true | dash=true. (2) Backup walked the tree and threw on the first symlink; ~/.hermes has 58 and ~/.openclaw 2063, 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.cp now takes a filter that skips node_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 honours homeDir, so HERMES_HOME is no longer ignored, and manifest.json gained source + 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 -a and 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 an Upgrade, so its panels stay empty and those features open on a CLI view with the reason stated; the docker and package detection 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 and managed-app.action audit lines still carry actor: null; the workspace switcher is not yet a visible control in the macOS/Windows/iOS/Android chrome; an upstream can still broaden its own connect-src to 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 in docs/MANAGED-APPS.md, and per-app docs/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 a use-thread-persistence hook. YAML (not JSON) per the owner's request — readable session files (yaml dep 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/models now 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/models catalog; 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 (kind oauth), 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/completions path does NOT work — Codex hits chatgpt.com/backend-api/codex/responses with the OAuth bearer, the account id decoded from the token JWT, and SSE response.output_text.delta. Public Codex-CLI client id (no secret, no registration). The assistant route bypasses resolveModel for openai-codex, refreshes the token (120 s margin) before each call, streams via streamCodex.
  • 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.tsx reads useInspectorInfo(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 new AppActionsSheet (shadcn Sheet side=bottom). No per-slice edits, no new bus. Did NOT rebuild to the mock's prepare(ctx)→os merge 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), a protocol override on resolveModel (lib/models/resolve.js), /api/config GET-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.service to 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_key with 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-cloud CLI credential import that reads only ~/.convex/config.json, refuses symlink/non-owner inputs, hardens the local credential directory/file to 0700/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 / convexSite URLs. Canonical operations mint a scoped short-lived deploy key and revoke it in finally; 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.readLogs APIs.
  • 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 generic git, 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_ID and AUTH_GOOGLE_SECRET; therefore its custom convexSite remains non-canonical until the Google OAuth redirect URI is migrated.

2026-09-06 — Private DOKU MCP connections

  • Added doku as 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-RPC initialize request before saving.
  • Portable connection mapping supports DOKU_MCP_CLIENT_ID, DOKU_MCP_API_KEY, and DOKU_MCP_ENV; credential values remain redacted from summaries and tool output.

2026-09-06 — DOKU Payment + MCP credential separation

  • Expanded the native doku integration from MCP-only to two explicit methods: Payment REST (Payment Client ID + HMAC Payment 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 Found response is accepted; Invalid Merchant 404 remains fail-closed.
  • MCP credential verification remains a fixed-endpoint MCP initialize request. 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.deploy for 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/session has no mcp request field and its 201 response carries mcp.url without headers, so a stored session previously had no credential and could never be called. mcpHeaders is now the exact header composioAuthHeader returned for the credential that authenticated that same create call (x-api-key project, x-user-api-key user, x-org-api-key org), matching docs/sessions-via-mcp. A future response mcp.headers still 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 with invalid_composio_mcp_host. Header values stay server-side: the route still returns only mcpUrl.