@astrale-os/adapter-cloudflare 0.1.10 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/adapter-cloudflare",
-  "version": "0.1.10",
+  "version": "0.2.0",
   "description": "Deploy an Astrale domain as a standalone Cloudflare Worker",
   "keywords": [
     "adapter",

package/template/.agents/skills/astrale-cli/SKILL.md

@@ -91,7 +91,7 @@ Examples:
 
 ```bash
 astrale call /:blog.acme.com:class.Author:list
-astrale call /:blog.acme.com:interface.MonitorOps:watch url=https://astrale.ai
+astrale call /:blog.acme.com:class.Monitor:watch url=https://astrale.ai
 astrale call /blog.acme.com/alice::deactivate
 astrale call @f00d...::deactivate
 ```

package/template/client/README.md

@@ -3,9 +3,10 @@
 A small React + Vite SPA that renders the domain's Views. It is loaded inside an
 iframe mounted by the Astrale shell, runs the shell handshake (via the real
 `@astrale-os/shell`) to learn its target node id and a kernel session, fetches
-that node from the kernel, and renders it. The bundled `ui-monitor` view loads a
-Monitor and renders its status/url/latency, with a "Check now" button that calls
-the Monitor's `check` instance method and reloads the node. Built into `../.dist/`
+that node from the kernel, and renders it. The bundled status view loads a
+`Checkable` node (a Monitor or a StatusPage — both carry a `status` prop and a
+`::check` method) and renders its status, with a "Check now" button that calls
+the node's `check` instance method and reloads the node. Built into `../.dist/`
 and served by the generated worker (`.astrale/`) under `/ui/*` via its `ASSETS`
 binding.
 
@@ -16,18 +17,19 @@ client: `src/shell/use-shell.ts` boots `createShell({ mode: 'sandboxed' })`, and
 feature hooks call kernel methods through `shell.kernel` (token refresh, codec
 negotiation, redirect following, and delegation are all handled by the SDK — no
 inline wire code). `@` is aliased to `src/` (mirrors `tsconfig` paths), so feature
-code imports `@/shell`, `@/ui`, `@/monitor`.
+code imports `@/shell`, `@/ui`, `@/status`.
 
 ## Layout
 
 Feature-first: each feature owns its types/api/mappers/hooks/components. The
 `shell/` and `ui/` folders are the generic, domain-neutral seams every feature
-builds on.
+builds on. The template ships ONE feature, `status/`, over a `Checkable` node —
+one card loads the node and exposes its status + a "Check now" action.
 
 ```
 src/
   main.tsx              # entry → createRoot(App)
-  app.tsx               # path router: ROUTES { '/ui/monitor': MonitorView }
+  app.tsx               # path router: ROUTES { '/ui/status-page': StatusView }
   styles.css            # self-contained styles (no Tailwind), design tokens
   shell/                # GENERIC kernel/shell adapter on @astrale-os/shell
     client.ts           #   prop readers (PROP, readProp, readPropBySuffix) + errors
@@ -41,23 +43,23 @@ src/
     index.ts            #   barrel → @/shell
   ui/                   # PURE presentation — no kernel, no hooks
     surface.tsx         #   Panel / ErrorBanner / EmptyState / Spinner
-    badge.tsx           #   StatusBadge (up | down | unknown)
+    StatusBadge.tsx     #   StatusBadge (up | degraded | down | unknown)
     value.tsx           #   KV / Mono / ExternalLink
     format.ts           #   relativeTime
     index.ts            #   barrel → @/ui
-  monitor/              # THE Monitor feature (template example)
-    monitor.types.ts    #   MonitorRecord
-    monitor.api.ts      #   check(session, id) → @<id>::check
-    monitor.mappers.ts  #   monitorFromNode (node → record)
-    hooks/              #   useMonitor.query / useCheck.mutation
-    components/         #   MonitorCard (container: hooks + @/ui)
-    index.ts            #   barrel → @/monitor
+  status/               # THE status feature — polymorphic over Checkable nodes
+    status.types.ts     #   CheckableRecord
+    status.api.ts       #   check(session, id) → @<id>::check
+    status.mappers.ts   #   checkableFromNode (node → record)
+    hooks/              #   useCheckable.query / useCheck.mutation
+    components/         #   StatusCard (container: hooks + @/ui)
+    index.ts            #   barrel → @/status
   views/
-    monitor.tsx         #   MonitorView = <ViewFrame>…<MonitorCard/></ViewFrame>
+    status.tsx          #   StatusView = <ViewFrame>…<StatusCard/></ViewFrame>
 __tests__/
   harness.ts            # fake shell parent (real protocol) + fake kernel (fetch stub)
   app.test.tsx          # handshake → render → check now → setTarget → fallback
-  seam.test.tsx         # pure @/ui + @/monitor hooks in isolation (no handshake)
+  seam.test.tsx         # pure @/ui + @/status hooks in isolation (no handshake)
   kernel.test.ts        # pure helpers: prop readers, mapper, relativeTime
 ```
 
@@ -81,14 +83,14 @@ the generated worker forwards `/ui/*` to vite.
    and the `targetNodeId`). `useShell()` boots `@astrale-os/shell`, surfaces the
    kernel session, and tracks `setTarget` hot-swaps.
 3. A feature loads its node through the session: `useNode(session, nodeId)` calls
-   `@<id>::get` over `shell.kernel`, and a mapper (`monitorFromNode`) projects it
-   to a typed record. Domain props are read by key SUFFIX (`.property.url`, …)
-   because the domain origin is unknown at build time; the name uses the kernel
+   `@<id>::get` over `shell.kernel`, and a mapper (`checkableFromNode`) projects
+   it to a typed record. Domain props are read by key SUFFIX (`.property.status`,
+   …) because the domain origin is unknown at build time; the name uses the kernel
    `Named.name` key.
 4. Writes go through `useCapability`: "Check now" runs `@<id>::check`, then calls
-   `useMonitor`'s `reload()` so the fresh status/latency re-render. The shell's
-   kernel client owns the credential and refreshes it before expiry — features
-   never touch the token.
+   `useCheckable`'s `reload()` so the fresh status re-renders. The shell's kernel
+   client owns the credential and refreshes it before expiry — features never
+   touch the token.
 
 ## Adding a view
 
@@ -97,6 +99,6 @@ the generated worker forwards `/ui/*` to vite.
 3. Register a matching `defineView({ mount: '/ui/<path>' })` in the domain's
    `views/` so the shell mounts an iframe there.
 
-For a NEW feature, mirror `src/monitor/`: a `*.types.ts`, `*.api.ts`,
+For a NEW feature, mirror `src/status/`: a `*.types.ts`, `*.api.ts`,
 `*.mappers.ts`, a `hooks/` folder of `.query`/`.mutation` hooks, and a
 `components/` folder of containers that compose `@/ui`.

package/template/client/__tests__/app.test.tsx

@@ -2,21 +2,22 @@ import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 
 import { App } from '@/app'
-import { installFakeKernel, installFakeParent, monitorNode, ok } from './harness'
+
+import { checkableNode, installFakeKernel, installFakeParent, ok } from './harness'
 
 const KERNEL_URL = 'https://k.example.test/api'
 
 /**
  * The router picks a view from `window.location.pathname`, so every test mounts
- * at a known path. `replaceState` rewrites the happy-dom location without a
- * reload. Default to the Monitor detail path; the fallback test overrides.
+ * at the StatusPage view's path. `replaceState` rewrites the happy-dom location
+ * without a reload; the fallback test overrides it.
  */
 function mountAt(path: string) {
   window.history.replaceState({}, '', path)
 }
 
 beforeEach(() => {
-  mountAt('/ui/monitor')
+  mountAt('/ui/status-page')
 })
 
 afterEach(() => {
@@ -38,30 +39,22 @@ function handshake(targetNodeId?: string) {
   return installFakeParent({
     windowId: 'win-1',
     kernelUrl: KERNEL_URL,
-    functionId: 'ui-monitor',
+    functionId: 'ui-status-page',
     delegationToken: 'tok-A',
     tokenExpiresAt: Date.now() + 3_600_000,
     targetNodeId,
   })
 }
 
-describe('monitor view (/ui/monitor)', () => {
-  it('loads the target node and renders name, url, status and latency', async () => {
-    const parent = handshake('mon-1')
+/** A StatusPage node fixture — its rolled-up `status`, no `url`. */
+const page = (id: string, status: string, name = 'Public status') =>
+  checkableNode({ id, name, status, className: 'StatusPage' })
+
+describe('status view (/ui/status-page)', () => {
+  it('loads the StatusPage node and renders its name + rolled-up status', async () => {
+    const parent = handshake('page-1')
     const kernel = installFakeKernel((body) => {
-      if (body.method === '@mon-1::get') {
-        return ok(
-          monitorNode({
-            id: 'mon-1',
-            name: 'API health',
-            url: 'https://api.example.test/health',
-            status: 'up',
-            statusCode: '200',
-            latencyMs: '42',
-            lastCheckedAt: '2026-06-14T10:00:00Z',
-          }),
-        )
-      }
+      if (body.method === '@page-1::get') return ok(page('page-1', 'degraded'))
       return { error: { code: 3002, message: `unexpected: ${body.method}` } }
     })
 
@@ -72,36 +65,15 @@ describe('monitor view (/ui/monitor)', () => {
       // Parent observed the child's handshakeAck.
       await expect(parent.ack).resolves.toBeUndefined()
 
-      expect(screen.getByText('API health')).toBeTruthy()
-      // ExternalLink strips the scheme.
-      expect(screen.getByText('api.example.test/health')).toBeTruthy()
-      const badge = screen.getByText('UP')
-      expect(badge.className).toContain('status-up')
-      expect(screen.getByText('42ms')).toBeTruthy()
-      expect(screen.getByText('200')).toBeTruthy()
+      expect(screen.getByText('Public status')).toBeTruthy()
+      const badge = screen.getByText('DEGRADED')
+      expect(badge.className).toContain('status-degraded')
+      // A StatusPage carries no `url`, so there's no url row.
+      expect(screen.queryByText('url')).toBeNull()
 
       // Exactly one kernel call, for the node load.
       expect(kernel.calls).toHaveLength(1)
-      expect(kernel.calls[0]!.body.method).toBe('@mon-1::get')
-    } finally {
-      kernel.restore()
-      parent.restore()
-    }
-  })
-
-  it('renders a DOWN badge when the monitor status is down', async () => {
-    const parent = handshake('mon-d')
-    const kernel = installFakeKernel(() =>
-      ok(monitorNode({ id: 'mon-d', name: 'Down site', url: 'https://x.test', status: 'down' })),
-    )
-
-    try {
-      render(<App />)
-      await flush()
-
-      const badge = screen.getByText('DOWN')
-      expect(badge).toBeTruthy()
-      expect(badge.className).toContain('status-down')
+      expect(kernel.calls[0]!.body.method).toBe('@page-1::get')
     } finally {
       kernel.restore()
       parent.restore()
@@ -109,36 +81,25 @@ describe('monitor view (/ui/monitor)', () => {
   })
 
   it('clicks "Check now", issues @<id>::check, and reflects the refreshed status', async () => {
-    const parent = handshake('mon-1')
-    // First ::get is down; ::check mutates server-side; the post-check ::get is up.
+    const parent = handshake('page-1')
+    // First ::get is down; ::check rolls up server-side; the post-check ::get is up.
     let checked = false
     const kernel = installFakeKernel((body) => {
-      if (body.method === '@mon-1::check') {
+      if (body.method === '@page-1::check') {
         checked = true
         return ok(null)
       }
-      // @mon-1::get — reflect the pre/post-check status.
-      return ok(
-        monitorNode({
-          id: 'mon-1',
-          name: 'API health',
-          url: 'https://api.example.test/health',
-          status: checked ? 'up' : 'down',
-          statusCode: checked ? '200' : '503',
-        }),
-      )
+      return ok(page('page-1', checked ? 'up' : 'down'))
     })
 
     try {
       render(<App />)
       await flush()
 
-      // Initial load: DOWN.
       expect(screen.getByText('DOWN')).toBeTruthy()
       expect(kernel.calls).toHaveLength(1)
-      expect(kernel.calls[0]!.body.method).toBe('@mon-1::get')
+      expect(kernel.calls[0]!.body.method).toBe('@page-1::get')
 
-      // Click "Check now".
       await act(async () => {
         fireEvent.click(screen.getByText('Check now'))
       })
@@ -146,14 +107,11 @@ describe('monitor view (/ui/monitor)', () => {
 
       // A ::check call was issued, then the node was re-fetched.
       expect(kernel.calls.map((c) => c.body.method)).toEqual([
-        '@mon-1::get',
-        '@mon-1::check',
-        '@mon-1::get',
+        '@page-1::get',
+        '@page-1::check',
+        '@page-1::get',
       ])
-
-      // The refreshed status renders.
       expect(screen.getByText('UP')).toBeTruthy()
-      expect(screen.getByText('200')).toBeTruthy()
     } finally {
       kernel.restore()
       parent.restore()
@@ -161,13 +119,12 @@ describe('monitor view (/ui/monitor)', () => {
   })
 
   it('surfaces a check failure without losing the loaded record', async () => {
-    const parent = handshake('mon-1')
-    const kernel = installFakeKernel((body) => {
-      if (body.method === '@mon-1::check') {
-        return { error: { code: 2004, message: 'Permission denied' } }
-      }
-      return ok(monitorNode({ id: 'mon-1', name: 'API health', url: 'https://x.test', status: 'up' }))
-    })
+    const parent = handshake('page-1')
+    const kernel = installFakeKernel((body) =>
+      body.method === '@page-1::check'
+        ? { error: { code: 2004, message: 'Permission denied' } }
+        : ok(page('page-1', 'up')),
+    )
 
     try {
       render(<App />)
@@ -183,7 +140,7 @@ describe('monitor view (/ui/monitor)', () => {
       expect(screen.getByText(/Check failed:/)).toBeTruthy()
       expect(screen.getByText(/Permission denied/)).toBeTruthy()
       // The record is still shown.
-      expect(screen.getByText('API health')).toBeTruthy()
+      expect(screen.getByText('Public status')).toBeTruthy()
     } finally {
       kernel.restore()
       parent.restore()
@@ -198,8 +155,7 @@ describe('monitor view (/ui/monitor)', () => {
       render(<App />)
       await flush()
 
-      expect(screen.getByText(/Failed to load the Monitor/)).toBeTruthy()
-      // The proper client maps NOT_FOUND (3002) to a typed error → clean message.
+      expect(screen.getByText(/Failed to load/)).toBeTruthy()
       expect(screen.getByText(/Path not found/)).toBeTruthy()
     } finally {
       kernel.restore()
@@ -208,24 +164,24 @@ describe('monitor view (/ui/monitor)', () => {
   })
 
   it('re-fetches on a setTarget hot-swap', async () => {
-    const parent = handshake('mon-1')
+    const parent = handshake('page-1')
     const kernel = installFakeKernel((body) =>
-      body.method === '@mon-2::get'
-        ? ok(monitorNode({ id: 'mon-2', name: 'Second monitor', url: 'https://b.test', status: 'down' }))
-        : ok(monitorNode({ id: 'mon-1', name: 'First monitor', url: 'https://a.test', status: 'up' })),
+      body.method === '@page-2::get'
+        ? ok(page('page-2', 'down', 'Internal status'))
+        : ok(page('page-1', 'up', 'Public status')),
     )
 
     try {
       render(<App />)
       await flush()
-      expect(screen.getByText('First monitor')).toBeTruthy()
+      expect(screen.getByText('Public status')).toBeTruthy()
       expect(screen.getByText('UP')).toBeTruthy()
 
       // Parent pushes a new target node.
-      parent.setTarget('mon-2')
+      parent.setTarget('page-2')
       await flush()
 
-      expect(screen.getByText('Second monitor')).toBeTruthy()
+      expect(screen.getByText('Internal status')).toBeTruthy()
       expect(screen.getByText('DOWN')).toBeTruthy()
     } finally {
       kernel.restore()
@@ -240,7 +196,7 @@ describe('monitor view (/ui/monitor)', () => {
       render(<App />)
       await flush()
 
-      expect(screen.getByText(/No target Monitor/)).toBeTruthy()
+      expect(screen.getByText(/No target node/)).toBeTruthy()
       expect(kernel.calls).toHaveLength(0)
     } finally {
       kernel.restore()

package/template/client/__tests__/harness.ts

@@ -240,37 +240,32 @@ export function fakeKernelSession(kernelUrl = 'https://k.example.test/api'): Ker
 }
 
 /**
- * Build a minimal kernel Monitor node whose props carry url/status/statusCode/
- * latencyMs/lastCheckedAt, with the same domain-qualified key format the kernel
- * uses (`<domain>:class.Monitor.property.<name>`). The name uses the kernel
+ * Build a minimal kernel `Checkable` node — a StatusPage (or any class via
+ * `className`, default `StatusPage`). Carries a domain-qualified `status` prop
+ * (`<domain>:class.<className>.property.status`); the name uses the kernel
  * `Named.name` key.
  */
-export function monitorNode(opts: {
+export function checkableNode(opts: {
   id: string
   path?: string
   name?: string
-  url?: string
   status?: string
-  statusCode?: string
-  latencyMs?: string
-  lastCheckedAt?: string
+  className?: string
   domain?: string
 }): { id: string; path: string; class: { raw: string }; props: Record<string, unknown> } {
   const domain = opts.domain ?? 'monitors.astrale.ai'
-  const base = `${domain}:class.Monitor.property`
+  const className = opts.className ?? 'StatusPage'
   const props: Record<string, unknown> = {}
   if (opts.name !== undefined) {
     props['kernel.astrale.ai:interface.Named.property.name'] = opts.name
   }
-  if (opts.url !== undefined) props[`${base}.url`] = opts.url
-  if (opts.status !== undefined) props[`${base}.status`] = opts.status
-  if (opts.statusCode !== undefined) props[`${base}.statusCode`] = opts.statusCode
-  if (opts.latencyMs !== undefined) props[`${base}.latencyMs`] = opts.latencyMs
-  if (opts.lastCheckedAt !== undefined) props[`${base}.lastCheckedAt`] = opts.lastCheckedAt
+  if (opts.status !== undefined) {
+    props[`${domain}:class.${className}.property.status`] = opts.status
+  }
   return {
     id: opts.id,
-    path: opts.path ?? `/monitors/${opts.id}`,
-    class: { raw: `/:${domain}:class.Monitor` },
+    path: opts.path ?? `/${opts.id}`,
+    class: { raw: `/:${domain}:class.${className}` },
     props,
   }
 }

package/template/client/__tests__/kernel.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, it } from 'vitest'
 
 import { qualifiedString, readProp, readPropBySuffix } from '@/shell'
-import { monitorFromNode, normalizeStatus } from '@/monitor'
+import { checkableFromNode } from '@/status'
 import { relativeTime } from '@/ui'
-import { monitorNode } from './harness'
+
+import { checkableNode } from './harness'
 
 describe('prop readers', () => {
   it('readProp returns the string value at the exact key', () => {
@@ -30,45 +31,18 @@ describe('prop readers', () => {
   })
 })
 
-describe('monitorFromNode mapper', () => {
-  it('projects name, url, normalized status and coerced numbers', () => {
-    const record = monitorFromNode(
-      monitorNode({
-        id: 'mon-1',
-        name: 'API health',
-        url: 'https://api.test/health',
-        status: 'up',
-        statusCode: '200',
-        latencyMs: '42',
-        lastCheckedAt: '2026-06-14T10:00:00Z',
-      }),
+describe('checkableFromNode mapper', () => {
+  it('projects the name and rolled-up status of a StatusPage node', () => {
+    const record = checkableFromNode(
+      checkableNode({ id: 'page-1', name: 'Public', status: 'degraded', className: 'StatusPage' }),
     )
-    expect(record).toMatchObject({
-      id: 'mon-1',
-      name: 'API health',
-      url: 'https://api.test/health',
-      status: 'up',
-      statusCode: 200,
-      latencyMs: 42,
-      lastCheckedAt: '2026-06-14T10:00:00Z',
-    })
+    expect(record).toEqual({ name: 'Public', status: 'degraded' })
   })
 
   it('falls back to the path segment for the name and unknown for a missing status', () => {
-    const record = monitorFromNode(monitorNode({ id: 'mon-9', path: '/monitors/edge' }))
+    const record = checkableFromNode(checkableNode({ id: 'page-9', path: '/status-pages/edge' }))
     expect(record.name).toBe('edge')
     expect(record.status).toBe('unknown')
-    expect(record.url).toBe('')
-    expect(record.statusCode).toBeUndefined()
-  })
-})
-
-describe('normalizeStatus', () => {
-  it('passes through up/down and maps everything else to unknown', () => {
-    expect(normalizeStatus('up')).toBe('up')
-    expect(normalizeStatus('down')).toBe('down')
-    expect(normalizeStatus('weird')).toBe('unknown')
-    expect(normalizeStatus(undefined)).toBe('unknown')
   })
 })
 

package/template/client/__tests__/seam.test.tsx

@@ -1,20 +1,21 @@
 /**
  * What the presentation/logic seam unlocks:
  *
- *  1. PRESENTATION components (`@/ui` and a feature's own `monitor/ui`) test with
- *     ZERO infrastructure — no fake shell, no fake kernel, no session. Just props
- *     in, DOM out. (Contrast app.test.tsx, which stands up a handshake + kernel
- *     stub to reach the same markup.)
- *  2. FEATURE hooks (`@/monitor`) test against a bare `KernelClient` (the fake
+ *  1. PRESENTATION components (`@/ui`) test with ZERO infrastructure — no fake
+ *     shell, no fake kernel, no session. Just props in, DOM out. (Contrast
+ *     app.test.tsx, which stands up a handshake + kernel stub to reach the same
+ *     markup.)
+ *  2. FEATURE hooks (`@/status`) test against a bare `KernelClient` (the fake
  *     kernel fetch stub) with no handshake — the write lifecycle and the
  *     reload signal are verified once, in isolation.
  */
 import { act, cleanup, render, renderHook, screen, waitFor } from '@testing-library/react'
 import { afterEach, describe, expect, it } from 'vitest'
 
-import { useCheck, useMonitor } from '@/monitor'
-import { StatusBadge } from '@/monitor/ui'
-import { fakeKernelSession, installFakeKernel, monitorNode, ok } from './harness'
+import { useCheck, useCheckable } from '@/status'
+import { StatusBadge } from '@/ui'
+
+import { checkableNode, fakeKernelSession, installFakeKernel, ok } from './harness'
 
 afterEach(cleanup)
 
@@ -23,24 +24,25 @@ describe('presentation is pure (no kernel, no session, no shell)', () => {
     const { rerender } = render(<StatusBadge status="up" />)
     expect(screen.getByText('UP').className).toContain('status-up')
 
+    rerender(<StatusBadge status="degraded" />)
+    expect(screen.getByText('DEGRADED').className).toContain('status-degraded')
+
     rerender(<StatusBadge status="down" />)
     expect(screen.getByText('DOWN').className).toContain('status-down')
 
-    rerender(<StatusBadge status="unknown" />)
+    rerender(<StatusBadge status="weird" />)
     expect(screen.getByText('UNKNOWN').className).toContain('status-unknown')
   })
 })
 
-describe('useMonitor — query + reload signal', () => {
+describe('useCheckable — query + reload signal', () => {
   it('loads the record, then exposes reloading across a reload()', async () => {
     const session = fakeKernelSession()
     let status = 'down'
-    const kernel = installFakeKernel(() =>
-      ok(monitorNode({ id: 'mon-1', name: 'API', url: 'https://x.test', status })),
-    )
+    const kernel = installFakeKernel(() => ok(checkableNode({ id: 'page-1', name: 'API', status })))
 
     try {
-      const { result } = renderHook(() => useMonitor(session, 'mon-1'))
+      const { result } = renderHook(() => useCheckable(session, 'page-1'))
       await waitFor(() => expect(result.current.state).toBe('ok'))
       expect(result.current.record?.status).toBe('down')
       expect(result.current.reloading).toBe(false)
@@ -63,7 +65,7 @@ describe('useMonitor — query + reload signal', () => {
     const session = fakeKernelSession()
     const kernel = installFakeKernel(() => ({ error: { code: 3002, message: 'Path not found' } }))
     try {
-      const { result } = renderHook(() => useMonitor(session, 'missing'))
+      const { result } = renderHook(() => useCheckable(session, 'missing'))
       await waitFor(() => expect(result.current.state).toBe('error'))
       expect(result.current.message).toMatch(/Path not found/)
     } finally {
@@ -77,7 +79,7 @@ describe('useCheck — the shared write-lifecycle', () => {
     const session = fakeKernelSession()
     const kernel = installFakeKernel(() => ok(null))
     try {
-      const { result } = renderHook(() => useCheck(session, 'mon-1'))
+      const { result } = renderHook(() => useCheck(session, 'page-1'))
       expect(result.current.phase).toBe('idle')
 
       let returned: boolean | undefined
@@ -94,9 +96,11 @@ describe('useCheck — the shared write-lifecycle', () => {
 
   it('captures a failure: phase failed, error set, resolves false', async () => {
     const session = fakeKernelSession()
-    const kernel = installFakeKernel(() => ({ error: { code: 2004, message: 'Permission denied' } }))
+    const kernel = installFakeKernel(() => ({
+      error: { code: 2004, message: 'Permission denied' },
+    }))
     try {
-      const { result } = renderHook(() => useCheck(session, 'mon-1'))
+      const { result } = renderHook(() => useCheck(session, 'page-1'))
       let returned: boolean | undefined
       await act(async () => {
         returned = await result.current.run()

package/template/client/src/app.tsx

@@ -1,27 +1,21 @@
 /**
- * Multi-view router for the domain's one SPA bundle.
+ * Path-based view router for the domain's SPA bundle. The shell mounts each Astrale
+ * View in its own iframe at its own mount path, so inside the iframe
+ * `window.location.pathname` IS that path. `App` reads it (via `resolveView`) and
+ * renders the matching view; an unregistered path shows a self-describing fallback.
  *
- * The domain declares its SPA Views, each served from THIS one bundle under
- * `/ui/*` and mounted by the shell as its own iframe at its own mount path:
- *   - `/ui/monitor` → the Monitor detail panel (`views/monitor.tsx`)
- *
- * Because the shell mounts one iframe per view at its mount path, inside the
- * iframe `window.location.pathname` is that path. `App` reads it (via
- * `resolveView`) and renders the matching view; an unregistered path shows a
- * self-describing fallback.
- *
- * To add a view:
- *   1. write a `ViewComponent` (usually wrapping `ViewFrame` — see `views/`),
- *   2. add a `ROUTES` entry below keyed by its mount path,
- *   3. register a matching `defineView({ mount: '/ui/<path>' })` in the domain's
- *      `views/` so the shell mounts an iframe there.
+ * Today there's one view — the StatusPage panel at `/ui/status-page`. The router
+ * (not a direct render) is the extension seam: add a view by
+ *   1. writing a `ViewComponent` (usually wrapping `ViewFrame` — see `views/`),
+ *   2. adding a `ROUTES` entry keyed by its mount path,
+ *   3. registering a matching `defineView({ mount: '/ui/<path>' })` in `views/`.
  */
 
 import { resolveView, useShell, type ViewRoutes } from '@/shell'
-import { MonitorView } from '@/views/monitor'
+import { StatusView } from '@/views/status'
 
 const ROUTES: ViewRoutes = {
-  '/ui/monitor': MonitorView,
+  '/ui/status-page': StatusView,
 }
 
 export function App() {

package/template/client/src/shell/use-capability.ts

@@ -29,9 +29,7 @@ export interface Capability<P = void> {
   reset: () => void
 }
 
-export function useCapability<P = void>(
-  perform: (params: P) => Promise<unknown>,
-): Capability<P> {
+export function useCapability<P = void>(perform: (params: P) => Promise<unknown>): Capability<P> {
   const [phase, setPhase] = useState<Phase>('idle')
   const [error, setError] = useState<string | null>(null)
 

package/template/client/src/shell/use-node.ts

@@ -1,7 +1,7 @@
-import { useCallback, useEffect, useState } from 'react'
-
 import type { KernelClient } from '@astrale-os/shell'
 
+import { useCallback, useEffect, useState } from 'react'
+
 import { errorMessage, type KernelNode } from './client'
 
 export type NodeState =