Skip to content

Week 39 · 21–27 September 2026 ​

The biggest change this week is that a tenant's apps stop being islands. One app can call another's operations, and one app can receive another's events, both inside the same tenant, with no token to paste, no hostname to configure and no outbound allowlist entry. The platform says who is calling; you declare who may call you and what they may do. Alongside it, a capability arrives: authority carried by a secret rather than held by a person, which is what a share link has to be if the permission checker is to enforce it. Scheduled work gets a real off switch — one that a reconcile, a re-grant, a promote or a point-in-time rewind cannot quietly undo. Observability turns a request into a record: what the call ran, what it emitted, how it ended, and now your own log lines beside it, grouped by the sentence you wrote rather than by the values you filled in. The dashboard gets a plain-language home page. And a family of limits a Durable Object enforces in production — and Node never did — is now enforced in your own test run.

One published contract narrows: a permission key is at most 41 bytes. Details in "One breaking change" below.

Two apps in one tenant can call each other ​

A vertical can now invoke another vertical's operations, when both are installed in the same tenant. The caller writes two things:

json
{ "substrat": { "calls": ["acme/crm"] } }
ts
const result = await peerClient('acme/crm').invoke('customer/list', { limit: 50 });

There is no address, no token and no credential. The platform asserts who is calling, because the call goes to one reserved address that resolves in no DNS zone: the egress hop every dispatched request already passes through recognises it, and hands it to the router with the caller taken from the dispatch — the {app, tenant, scope} the router itself set when it dispatched the caller. The request body cannot carry an identity; the schema refuses one. A call raised where that hop cannot see it does not leave the isolate.

What the caller may then do is the target's decision, declared in its own manifest and reviewed in its permission diff:

ts
peers: [{ vertical: 'acme/crm', operations: ['customer/list'], permissions: ['customer:read'] }]

An app on nobody's list is refused. An operation off the allowlist is refused at the door. A peer holds exactly the keys the target declared, seated on the scope when it is provisioned — so editing that declaration reaches a running scope when the target is deployed and re-provisioned, not on the next call. What the door re-reads on every call, inside the scope's own serialized turn, is that the caller is still a declared peer, that the operation is on its allowlist, and that its cut-off is still on: pulling the cut-off refuses the very next call, and while it is off no re-provision hands the grants back. A peer is never a person: every event, denial and audit row names the calling app and the instance it called from, so an audit can ask which app, and which of that app's installs. A preview or a fork is never a caller and never a target, and a target that resolves to two installs is refused rather than guessed. Synchronous chains are depth-bounded.

Module code takes the other route. Operations, consumers and schedules run where there is no network by rule, so a handler reaches a peer by enqueuing a platform request, delivered with the caller taken from the scope the row was found in. At-least-once, keyed on the request id.

The lever, for the tenant. "May my other app still call in here?" is a question about the tenant's own two apps, so — unlike the schedule switch below — the tenant can answer it. The dashboard's app page discloses both directions after an install (what this app may call, and who may call it) and carries a cut-off and a restore, each with a recorded reason. The console has the same for staff. The panel keeps four states apart that it would be tempting to merge: switched off (somebody pulled the lever, and restoring undoes it), no grant (the target never declared this app, so restoring is not the remedy), unreadable (the position could not be read — never shown as "allowed", because a tenant told "allowed" believes something nobody checked), and not installed, which is the ordinary state of a fresh install and renders as nothing wrong.

Operator step: the egress worker needs a binding to the router's peer entrypoint, and the router must be deployed before it. An environment without it refuses every peer call with a message naming the binding and the worker, rather than a vague "not available" — because whoever reads it is looking at a vertical's code, not at deployment config.

An app can receive another app's events ​

The same pair of apps can be connected by events instead of calls. The producer declares what may leave; the consumer declares what it takes and from whom:

ts
// Producer
exports: eventsExportedBy(ops, { 'crm.customer-created': 'customer:read' }),

// Consumer
consumes: [{ from: 'acme/crm', type: 'crm.customer-created', schemaVersion: 1 }],
imports: { 'acme/crm': { 'crm.customer-created': async (ctx, event) => { … } } },

Delivery has the guarantees an in-scope consumer has: at-least-once, a journal, dead letters, a cascade limit, and a cause chain that crosses the edge and says where it continues on the other side. Three design points are worth knowing because they decide what you can rely on:

  • It is a pull on a watermark the consumer holds, not a copy pushed per event. So a consumer installed later backfills from the start, a restore of the consumer rewinds its position along with its data, a paused edge loses nothing (the backlog waits in the producer's outbox), and no fat second copy of every event rests in the producer's spine.
  • Only events classified as carrying no personal data cross. Erasure is per scope, and what a consumer derives from a crossed payload lands in its own tables, which no erasure reaches. The rule is enforced when you declare the export and again when the event is read.
  • Version skew fails loudly. Delivery matches on type and schemaVersion; a mismatch is withheld and dead-lettered rather than handed to a handler that would parse it as something else.

Either side can pause the edge, and pausing is not dropping: nothing is read, the watermark holds, and switching back on delivers the backlog.

Delivery is seconds, not a sweep tick: a response that committed an exported event flags itself, and the router's existing drain kick runs that producer's outgoing edges. The kick is coalesced per producer — at most one pass per window, plus one trailing pass per burst, fleet-wide — so tenant traffic cannot amplify it, and a caller cannot forge one. Where the kick cannot see the commit (a peer call, a schedule, another app's delivery), the regular sweep still delivers.

Three operator surfaces come with it:

  • Edge health, per app on the dashboard and per scope in the console: each edge reads caught up, behind (with the lag of the oldest waiting event), paused (and by which side, and why), unresolved, or unavailable — which is its own state and never renders green. A failed read shows as a failure, not as "no edges".
  • A replay lever, to move a consumer's position on one edge: replay from a point, or skip forward. Both require an acknowledgement in words, because a replay runs every importing handler again and anything they send outside the app happens again. A skip can never be aimed past now.
  • A promote refusal. Promoting code that drops or re-versions an exported event type another installed app imports is now refused unless acknowledged, in the dashboard, the console and substrat promote --ack-export-break. It fails closed: a registry read that throws refuses the promote rather than waving it through. A tenant sees the affected apps in its own tenant and only a count of the rest.

Exported payload schemas are also now held to D-22 in CI: at an unchanged schemaVersion, a removed, retyped, newly required or no-longer-required field is red, because somebody else's deployed code parses it.

A vertical can now share by link, and the permission checker — not the route — is what enforces what the link reaches. A capability is authority carried by a secret rather than held by a principal: anyone with this link may read this folder until Friday.

ts
assertAllowed(await ctx.check(PERM.folderShare, folderRef));
const { secret } = await ctx.capabilities.mint({
  entity: folderRef,
  permissions: [PERM.folderRead],
  expiresAt,
});
return { link: `${origin}/#share=${secret}` };

Whoever exchanges that secret acts as the capability. It is a first-class actor: resolved by the checker, stamped on every event it causes, and written into the denial log when it is refused — the same treatment a connector's actor gets.

The rules that make it safe to hand out:

  • A link never grants more than its minter holds, checked on every use. So a link dies when the person who made it loses access, and works again if they get it back.
  • Exactly one subtree, exactly its keys. It reaches its entity and what lies beneath it through the same parent walk entity grants use — a sibling folder, a sibling's document, a key it does not carry and anything at the scope level are all refused and recorded.
  • Revocation is the next call. The row is read on every check and the session is re-resolved on every invoke, so a session handed out before a revoke is refused after it.
  • The platform stores only the secret's hash, and nothing the platform writes carries the secret. A tripwire additionally refuses — and rolls back — a mint whose own invocation tries to persist the secret verbatim through an event, a platform request or ctx.sql. That catches an accident; it is not a boundary against a module that means to leak it, and the code says so.
  • The secret rides in the URL fragment, so it never reaches a server: not in a router log, not in an invocation log, not in a Referer, and a mail scanner fetching the URL cannot spend a single-use link.

Files came along with it. A link share now delivers the files under it: listing and opening check the file's entity as the capability, through the same evaluator branch an invoke meets. Uploads and removals through a link are refused structurally, even when the capability carries the write key, and the refusal is recorded. A download is not a use — only the exchange is — and the response always carries Content-Disposition: attachment with a sanitised filename, a sandbox CSP, nosniff and no-store. A browser can also hold several link shares at once now, rather than the last exchange winning.

On a link-share route the capability deliberately wins over a signed-in principal, so a recipient who happens to be signed in but holds nothing of their own still reads through the link.

An off switch for a scope's scheduled work ​

Scheduled work now has a kill switch, per module per scope, and it holds: while it is off, nothing hands that module's authority back on that scope.

  • Every schedule of that module stops firing, and reports skipped rather than failed — so a switched-off scope makes no noise on any pass. Its cadence clock is left alone, so after a restore everything due fires on the first pass.
  • Anything acting with the module's system authority is denied by its own permission check, including a resumable job run.
  • A reconcile does not undo it, and a promote sends a reconcile. A stray re-grant is refused rather than silently winning. Provisioning seats nothing for a switched-off subject, including a permission a newer version declares.
  • A restore gives back exactly what the switch took, never more: a permission revoked independently before the switch was pulled stays revoked through off and on.
  • Every move is audited intent first, then outcome, with a required reason, so the pair fails toward "we recorded the ask and not the result" and never toward a switch that moved with no row.

It is staff-only, deliberately, and the tenant credential is refused by name: a switch the switched party can flip back on is not a kill switch. (The peer switch above is the opposite call, for the reason given there.)

Three ways the position could previously be lost are now closed. A point-in-time rewind holds a scope's switched-off modules until the switch is back, including an off pulled during the rewind's own settle. A tenant-level grant is refused while any scope holds the module off. And a scope whose storage is wiped and re-seated has its switch re-asserted inside the same unit that re-seats it.

The console reads it rather than making anyone query SQL by hand: a Schedules on/off control on the scope page, and a Health → Services view that answers the question fleet-wide — which scopes are switched off, who pulled it, when and why — beside a fleet-wide connection-health read and a durable count of platform requests still pending. Connector calls are charted per provider.

Every request is a record, and your own log lines join it ​

The invocation line a vertical writes for each request becomes a record. It now carries the operation, a derived level (an escaped throw or a 5xx is error; a 4xx or a 200 carrying a problem code is warn), the problem code read before the vertical's own error mapping, which kind of principal made the call, the version the code was deployed as, and a summary of what the call emitted — the event count, the types, and the entities touched. Anything nothing filled in is written as null, never guessed. MCP tool calls now fill in the same record and carry an invocation id, so their events are stamped like any other.

Beside it, module code gets a logger:

ts
ctx.log.warn('reply to {ticketId} bounced: {reason}', { ticketId, reason });

ctx.log has debug, info, warn and error, and each call writes one structured line. The first argument is kept verbatim as the template, which is the whole point: every line from one call site shares it whatever the values are, so lines group by equality instead of by mining free text. The host stamps the tenant, scope, operation, invocation id and principal kind itself, and a field you name tenantId stays a field — it cannot forge the stamp. It never throws: it trims oversized values, drops keys the log platform would not index, stringifies what is not a primitive and swallows a failing sink, because failing an operation over a diagnostic is the wrong trade. It is deliberately not transactional — a rolled-back operation's line is kept, since those are the lines you opened the page for. Consumers get it too, with operation: null and a system principal.

On the dashboard, Logs gains Requests (a histogram, facets and the request list over that record) and Patterns: one row per template, with its dominant level, the template rendered with each {placeholder} marked as a value slot, a histogram over the window you are looking at, and its share of all log lines. Clicking a row opens Lines filtered to that template. The empty state says why a pattern list can be empty while Lines has rows — a console.log line carries no template — and a platform that cannot answer reads as "not available here", never as "nothing logged". The same reads exist at tenant grain.

Two more things now name the call they ran in: a schedule's row, and — from earlier in this line of work — a delivery that gave up, which links straight to that call's logs.

The dashboard gets a home, and Observability gets rooms ​

/overview is now a plain-language home page rather than a table. A status card opens with a sentence composed deterministically from the reads — "Mostly working. 3 apps need attention, and an integration is erroring on its side" — which names the app when only one is affected, counts them when several are, says whose side a problem is on, and, if a read failed, says that instead of claiming all-clear. Under it: Needs attention, worst first, each row saying what and where, the reason, and one action that goes to the right place; the app grid with a health line and an "Observe →" link; integrations with a sentence built only from real fields; and the last few audit entries as sentences.

Observability splits into three children — Pulse (traffic, health, schedules), Processes (flow) and Logs (lines, requests, patterns, events) — each with its own layout. Switching child keeps your app filter and time window. Logs and Processes now ask you to pick an app instead of silently falling back to Traffic, which used to leave the menu naming a page you were not on. Flow is laid out in six columns, the event history carries investigation strips, the app page gained a header verdict, Deployments gained release comparison and schema history, traffic is stacked by HTTP status class with one overlay vocabulary throughout, and Audit → Activity renders as sentences by day, filtered by kind, expandable in place and deep-linkable. A pending invite's link can be copied from the Team page.

Your app's screens can update themselves ​

The live-read surface the platform gained last week now has its first real consumer, and the shared plumbing to go with it. A vertical declares which entity types may be watched and under which read key; the scope checks every frame against the subscriber's own permission on the entity that changed, so a subscription can never be wider than what a poll of the same screen would show. A frame says only that something changed — the client re-reads through the ordinary operation, so nothing bypasses the declared read surface.

The live route's origin gate and its "this platform cannot do live reads" answer now live in vertical-host rather than being restated per vertical, and the mode header comes from the kernel. Where live reads are unavailable — the Node dev server, for one — the route answers a 501 that says poll, and clients fall back without a branch in your code. Keep-alive pings are answered by the scope itself rather than waking it for each one.

One gap found by that first consumer is closed: the permission walk now reads a camelCase entity type, and the write verbs refuse an entity reference they cannot hold. Before, an entity-narrowed check that had to walk up from a camelCase type threw, and the fan-out read the throw as a refusal — so a subscriber was silently not sent frames a poll of the same screen would have shown them.

In practice, on the reference support desk: the inbox and the conversation view are pushed to, polling stays as a floor rather than being removed, a socket that opens and drops backs off and then rests, and a sign-out ends the feed.

The limits your production database enforces, now enforced in your tests ​

A Durable Object's SQLite refuses things Node's does not, and every one of those gaps has shipped a bug at some point. This week the gaps were measured against a real Durable Object, pinned, and wired into the test run:

LimitValue
Bound parameters in one statement100
Terms in one compound SELECT5
Statement length100 000 bytes
LIKE/GLOB pattern50 bytes
Columns replayed in a dump100

ctx.sql on the Node adapter now refuses what a Durable Object refuses, with the same message, so a vertical's own suite fails where production would. The whole preload chain also judges the platform's internal statements, not only module code — which is how a live failure was found and fixed this week: the hosted event drain marked its batch with one parameter per event and a batch defaults to 200, so every drain of more than 100 events threw and stamped nothing, and the next tick failed identically. Node allows 32 766 parameters, so no suite could see it. Every list-binding site on both adapters now binds one JSON array instead, and the documentation example that taught the old pattern was rewritten. A dump replay with more than 100 columns is refused on Node too, and a restore from a directory validates the dump the way the hosted path does.

The LIKE half landed as its own set of fixes: a source lint for long literals, a search term bounded by the bytes of the pattern a hosted desk will accept, and the 50-byte test limit published as @substrat-run/adapter-sqlite/testing so a vertical outside this repo can run its suite the way CI does. One export read's join order is now pinned, so collecting table statistics cannot cost it its index.

Promoting to production shows you what you are changing ​

The promote dialog now opens before the promote, not after a refusal. It compares the registry production is serving against the one being promoted and shows the permission changes — new, removed and re-worded keys with their descriptions, roles that gained or lost a permission, entity-grant shapes — and, now that a version's SQL migrations are stored apart from its manifest, the migration SQL itself. There is one checkbox per kind of change, a box exists only for a kind the dialog actually showed you, and only ticked kinds are sent: the dialog can never acknowledge something you were not shown. A failed review read blocks the promote rather than degrading to "no change". No change means no dialog. The console's promote dialog shows the same two things, and the CLI prints them.

The reference support desk ​

  • Service levels. First-response and resolution targets per priority, stamped on the conversation when it arrives and re-aimed (from when the customer started waiting, not from now) when its priority changes. A target already met or already missed stays put. A breach is recorded by one predicate through three doors — the sweep, a late reply or resolve, and a priority change — so a late answer cannot quietly become an on-time one, and the desk is told once. Switched off by default; no target means no breach.
  • Round-robin assignment, the first built-in behaviour a desk switches on.
  • Macros. A saved reply can carry an action bag — tag, set priority, assign, resolve — and applying it runs each action's own handler under the union of every part's permission keys, checked before anything is written. So a person who may reply but may not assign is refused the whole macro, and the trail shows the same events a person's clicks would produce. It is one transaction: a refusal halfway rolls back the reply too.
  • A snooze pauses the resolution target, and waking gives the time back.
  • Hosted schedules fire on the deployment's own sweeper, which is what makes the three above work on a deployed desk rather than only locally.
  • Assistant health and reaper reads are indexed, ingest and replies write through ctx.log, and malformed ids are refused at the input parse rather than deeper in.

Signing in, and where your login lives ​

  • A vertical's MCP endpoint is zero-config end to end. An MCP client registers itself, asks the team auth server for a token for the vertical's endpoint, and gets a login page instead of invalid_target. The token carries the endpoint as its audience, and the endpoint refuses a token minted for any other audience. The dashboard registers each app's active hostnames at the team's issuer on install, clears them on delete, and existing installs converge the next time anyone on the team loads the dashboard.
  • A login can see its places. The team auth server keeps an index of where a login holds a principal, and shows it on its own account page — tenant, app name, hostname, and a link in. Verticals never read any of it. Only the platform can register an app, and only the app's own registered client can add itself to a login's list, and only where the issuer has itself issued to that pair. Removals need no evidence, because they only reach the caller's own rows.
  • On a team auth server, a vertical now accepts only its own bearer tokens, which closes a hole where every bearer route on one app accepted any token the team issuer had signed.
  • Discovery is bound to the configured issuer, the client secret goes only to the issuer's own origin, a preview of an app gets its own client at the team auth server, and token exchange (RFC 8693) arrives gated by delegation grants.
  • An unknown MCP protocol version on initialize is treated as a proposal to negotiate rather than a refusal.

One breaking change ​

A permission key is now at most 41 bytes, and ctx.check parses the key it is handed rather than trusting the compile-time brand. A pushed vertical that declares a longer key is refused at manifest parse, as is a role or grant naming one.

41 is not arbitrary: the checker finds grants with a LIKE pattern built from the key, and a Durable Object refuses a pattern over 50 bytes. Before this, a 42-byte key parsed, deployed, and then threw on every hosted check. The longest key anywhere in this repo is 29 bytes, so nothing in tree is affected.

A malformed key now throws and names the key, rather than writing a denial row — a denial row saying "principal P was refused permission X" is misleading when X is not a permission, and it is not an available answer on the system-actor path at all. It fails closed: a throw returns no decision, so nothing can pass assertAllowed, and a caller that catches it and carries on has skipped a check rather than been granted one.

Security and correctness fixes ​

  • An erasure now reaches an intent's result and the job-run tables, which previously kept a subject's data after a shred.
  • Event facets withhold personal-data events from payload groupings, so an aggregate cannot become a way to read what the classification protects.
  • A reconcile keeps an operator's revoke, and re-seats the owner only on an actual lockout.
  • Hostname routing is gated on active scope and tenant lifecycle, and a preview can no longer be adopted into production or rebound.
  • Admin reads on the SQLite adapter run on a read-only connection and see only committed state; every scope-level admin write takes a turn on the scope actor, so a concurrent operation's rollback can no longer take a write that already answered success with it.
  • A promote of a listed vertical re-provisions its installs, paced, and never its forks.
  • One undecodable row no longer hides a whole list, a scope's whole journal, or the work behind it — on the spine and in the kernel's delivery and dead-letter reads, which now decode their columns instead of casting them.
  • The platform's sweep-run bookkeeping accepts only schedule and freshness entries.
  • Unknown-scope refusals are properly typed on both adapters, rather than arriving as untyped errors that a caller could not tell apart from a bug.
  • Connection-health search no longer substring-matches ids.
  • The SQL console and table browse read personal data and every query is logged; the docs now say so.

For hosted operators ​

  • Storage, on demand. A tenant's scope-database size can be read from the console by pressing a button: one page of scopes at a time (50 by default, 200 at most), at most eight reads in flight, with a partial failure shown as partial and left out of the sum rather than counted as zero. Attachments, per-tenant stores and the lake are named as excluded in the response, the card and the docs. Nothing is stored and no sweep runs — that is a later decision.
  • Each scope is read where its data actually lives, and when the plane delegates to verticals and none resolves, the read fails for that scope rather than falling back to a placeholder database and reporting its size.
  • Tenants can read the listed verticals they run.
  • A push to a preview carries its data into the new version's script.
  • The connector documentation now records why no connector sets a connection expiry.
  • CI builds are scoped to the diff and its dependents, the test job is sharded, and each shard runs two suites at a time rather than four.

Also landed ​

  • Engines: every engine's handler map is now bound to its declared operations with no cast on any entry — the clause that ties a handler's return type to its declaration, which no test can see deleted. Each engine also gets one home for each event's schemaVersion.
  • manyfold: five operations that declared a single object while returning a list or a page are corrected, list types are paged with cursors pushed into SQL, and its drive script is repaired for the OIDC-only server.
  • The builder studio's evaluation harness stops racing git on temp-directory cleanup and pins the wipe-failure path.
  • The CLI resolves a declared-surface entry absolutely, so a relative push directory works again.
  • A manifest is parsed before it is stored when a version is created, with unknown fields preserved.
  • vertical-auth's identity stub carries the site-registry methods.
  • The entity timeline keys each walk by a counter rather than by the record.
  • The secrets tool knows the tenant token secret, so push and check set and flag it.
  • Documentation: module code has no tenant-level storage; runtime-installed sandboxed extensions are outside K-15's scope; architecture enum and nullability drift is gated; test-environment data and seed-version wording are clarified; and the note that only the LIKE limit could slip past local tests is now out of date by the entry above, which is the good kind of out of date.
  • Test and tooling upkeep: the schedule contract suite asserts on its own scope's sweep errors, peer-invoke tests use deterministic versions, sweep-run fixtures no longer expire under the retention window, vitest is a required peer of the contract-test package rather than a bundled one, the auth server moved to better-auth 1.7.5 and dropped a column it stopped writing, dependencies moved within their declared ranges, and the lockfile was regenerated with pnpm 10.10.0.

Released ​

PackageSpan
@substrat-run/contracts0.117.0 → 0.125.0
@substrat-run/kernel0.117.0 → 0.125.0
@substrat-run/adapter-sqlite0.117.0 → 0.125.0
@substrat-run/adapter-cloudflare0.117.0 → 0.125.0
@substrat-run/vertical-host0.117.0 → 0.125.0
@substrat-run/control-plane-api0.117.0 → 0.125.0
@substrat-run/contract-tests0.117.0 → 0.125.0
@substrat-run/vertical-auth0.14.6 → 0.15.7
@substrat-run/cli0.33.1 → 0.36.3
@substrat-run/model-emit0.9.9 → 0.9.18
@substrat-run/model-view0.2.18 → 0.2.27
@substrat-run/model-providers0.5.7 → 0.5.15
@substrat-run/dev-issuer0.1.32 → 0.2.7
@substrat-run/boundary-lint0.5.0
@substrat-run/engine-invites0.8.1 → 0.9.2
@substrat-run/engine-workorder0.12.1 → 0.12.9
@substrat-run/engine-protocol0.13.1 → 0.13.9
@substrat-run/engine-invoicing0.11.1 → 0.11.9
@substrat-run/engine-booking0.8.1 → 0.8.9
@substrat-run/engine-absence0.6.1 → 0.6.9
@substrat-run/engine-metering0.6.1 → 0.6.9
@substrat-run/connector-scrive0.14.22 → 0.14.30
@substrat-run/connector-fortnox0.4.19 → 0.4.27
@substrat-run/connector-planima0.2.14 → 0.2.22
create-substrat0.9.9 → 0.10.0

The CLI's two minors are substrat.calls on push and the export-break acknowledgement; the invites engine's minor and vertical-auth's are the identity work above.