@swarmclawai/swarmclaw 1.9.12 → 1.9.13

package/README.md

@@ -399,6 +399,15 @@ Operational docs: https://swarmclaw.ai/docs/observability
 
 ## Releases
 
+### v1.9.13 Highlights
+
+Architecture health release: SwarmClaw now turns runtime ownership, dispatch, memory, startup, and quality evidence into a scored operator report.
+
+- **Architecture Health report.** `/api/quality/architecture-health` returns a structured inventory of runtime domains, surfaces, owners, guardrails, tests, score, risks, warnings, and next actions.
+- **Quality Center visibility.** `/quality` now shows a Runtime Ownership Map beside release readiness so operators can inspect dispatch, memory, startup, and quality coverage before shipping.
+- **Release gate integration.** Release readiness includes architecture health when scoring the ship gate report, blocking or warning when ownership evidence is incomplete.
+- **CLI access.** `swarmclaw operations architecture-health` exposes the same report for automation and release scripts.
+
 ### v1.9.12 Highlights
 
 Local file-queue connector release: operators can bridge SwarmClaw to filesystem inbox, outbox, archive, and error folders without a hosted message bus.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.9.12",
+  "version": "1.9.13",
   "description": "Build and run autonomous AI agents with OpenClaw, Hermes, multiple model providers, orchestration, delegation, memory, skills, schedules, and chat connectors.",
   "main": "electron-dist/main.js",
   "license": "MIT",
@@ -88,7 +88,7 @@
     "test:cli": "node --test src/cli/*.test.js bin/*.test.js scripts/electron-after-pack.test.mjs scripts/ensure-sandbox-browser-image.test.mjs scripts/postinstall.test.mjs scripts/run-next-build.test.mjs scripts/run-next-typegen.test.mjs",
     "test:setup": "tsx --test src/app/api/setup/check-provider/route.test.ts src/lib/server/provider-model-discovery.test.ts src/components/auth/setup-wizard/utils.test.ts src/components/auth/setup-wizard/types.test.ts src/hooks/setup-done-detection.test.ts src/lib/setup-defaults.test.ts src/lib/server/storage-auth.test.ts src/lib/server/storage-auth-docker.test.ts",
     "test:openclaw": "tsx --test src/lib/openclaw/openclaw-agent-id.test.ts src/lib/openclaw/openclaw-endpoint.test.ts src/lib/server/agents/agent-runtime-config.test.ts src/lib/server/build-llm.test.ts src/lib/server/connectors/connector-routing.test.ts src/lib/server/connectors/openclaw.test.ts src/lib/server/connectors/swarmdock.test.ts src/lib/server/gateway/protocol.test.ts src/lib/server/gateways/gateway-topology.test.ts src/lib/server/llm-response-cache.test.ts src/lib/server/mcp-conformance.test.ts src/lib/server/openclaw/agent-resolver.test.ts src/lib/server/openclaw/deploy.test.ts src/lib/server/openclaw/skills-normalize.test.ts src/lib/server/session-tools/openclaw-nodes.test.ts src/lib/server/session-tools/swarmdock.test.ts src/lib/server/tasks/task-quality-gate.test.ts src/lib/server/tasks/task-validation.test.ts src/lib/server/tool-capability-policy.test.ts src/lib/providers/openai.test.ts src/lib/providers/openclaw-exports.test.ts src/app/api/gateways/topology-route.test.ts src/app/api/openclaw/dashboard-url/route.test.ts",
-    "test:runtime": "tsx --test src/lib/a2a/agent-card.test.ts src/lib/strip-internal-metadata.test.ts src/lib/provider-sets.test.ts src/lib/providers/opencode-cli.test.ts src/lib/providers/cli-provider-metadata.test.ts src/lib/providers/cli-utils.test.ts src/lib/providers/generic-cli.test.ts src/lib/server/agents/delegation-advisory.test.ts src/lib/server/cli-provider-readiness.test.ts src/lib/server/provider-health.test.ts src/lib/server/mcp-gateway-runtime.test.ts src/lib/server/mcp-connection-pool.test.ts src/lib/server/knowledge-sources.test.ts src/lib/server/extension-managed-resources.test.ts src/lib/server/eval/baseline.test.ts src/lib/server/eval/environment-plan.test.ts src/lib/server/chat-execution/chat-execution-grounding.test.ts src/lib/server/chat-execution/chat-turn-preparation.test.ts src/lib/server/chat-execution/iteration-timers.test.ts src/lib/server/chat-execution/post-stream-finalization.test.ts src/lib/server/chat-execution/reasoning-tag-scrubber.test.ts src/lib/server/chats/clear-undo-snapshots.test.ts src/lib/server/connectors/email.test.ts src/lib/server/protocols/protocol-service.test.ts src/lib/server/runtime/run-ledger.test.ts src/lib/server/runtime/queue-retry-policy.test.ts src/lib/server/runs/run-brief.test.ts src/lib/server/operations/operation-pulse.test.ts src/lib/server/schedules/schedule-history.test.ts src/lib/quality/release-readiness.test.ts src/lib/server/artifacts/artifact-resolver.test.ts src/lib/server/observability/otel-config.test.ts src/lib/server/safe-parse-body.test.ts src/lib/server/missions/mission-templates.test.ts src/lib/server/sharing/share-link-repository.test.ts src/lib/server/sharing/share-resolver.test.ts src/lib/server/tasks/task-execution-workspace.test.ts src/lib/server/tasks/task-execution-policy.test.ts src/lib/server/tasks/task-handoff.test.ts src/lib/server/tasks/task-service.test.ts src/lib/server/session-tools/execute.test.ts src/lib/server/session-tools/manage-tasks.test.ts src/lib/app/view-constants.test.ts src/lib/quality/quality-summary.test.ts src/app/api/approvals/route.test.ts src/app/api/agents/agents-route.test.ts src/app/api/tasks/tasks-route.test.ts src/app/api/tasks/task-workspace-route.test.ts src/app/api/chats/chat-route.test.ts src/app/api/chats/clear-route.test.ts src/app/api/chats/compact-route.test.ts src/app/api/chats/context-status-route.test.ts src/app/api/connectors/connector-doctor-route.test.ts src/app/api/extensions/managed-resources/route.test.ts src/app/api/healthz/route.test.ts src/app/api/logs/route.test.ts src/app/api/portability/export/route.test.ts src/app/api/portability/import/route.test.ts src/app/api/providers/[id]/route.test.ts src/app/api/schedules/schedule-history-route.test.ts src/app/api/tts/route.test.ts",
+    "test:runtime": "tsx --test src/lib/a2a/agent-card.test.ts src/lib/strip-internal-metadata.test.ts src/lib/provider-sets.test.ts src/lib/providers/opencode-cli.test.ts src/lib/providers/cli-provider-metadata.test.ts src/lib/providers/cli-utils.test.ts src/lib/providers/generic-cli.test.ts src/lib/server/agents/delegation-advisory.test.ts src/lib/server/cli-provider-readiness.test.ts src/lib/server/provider-health.test.ts src/lib/server/mcp-gateway-runtime.test.ts src/lib/server/mcp-connection-pool.test.ts src/lib/server/knowledge-sources.test.ts src/lib/server/extension-managed-resources.test.ts src/lib/server/eval/baseline.test.ts src/lib/server/eval/environment-plan.test.ts src/lib/server/chat-execution/chat-execution-grounding.test.ts src/lib/server/chat-execution/chat-turn-preparation.test.ts src/lib/server/chat-execution/iteration-timers.test.ts src/lib/server/chat-execution/post-stream-finalization.test.ts src/lib/server/chat-execution/reasoning-tag-scrubber.test.ts src/lib/server/chats/clear-undo-snapshots.test.ts src/lib/server/connectors/email.test.ts src/lib/server/protocols/protocol-service.test.ts src/lib/server/runtime/run-ledger.test.ts src/lib/server/runtime/queue-retry-policy.test.ts src/lib/server/runs/run-brief.test.ts src/lib/server/operations/operation-pulse.test.ts src/lib/server/schedules/schedule-history.test.ts src/lib/quality/release-readiness.test.ts src/lib/quality/architecture-health.test.ts src/lib/server/artifacts/artifact-resolver.test.ts src/lib/server/observability/otel-config.test.ts src/lib/server/safe-parse-body.test.ts src/lib/server/missions/mission-templates.test.ts src/lib/server/sharing/share-link-repository.test.ts src/lib/server/sharing/share-resolver.test.ts src/lib/server/tasks/task-execution-workspace.test.ts src/lib/server/tasks/task-execution-policy.test.ts src/lib/server/tasks/task-handoff.test.ts src/lib/server/tasks/task-service.test.ts src/lib/server/session-tools/execute.test.ts src/lib/server/session-tools/manage-tasks.test.ts src/lib/app/view-constants.test.ts src/lib/quality/quality-summary.test.ts src/app/api/approvals/route.test.ts src/app/api/agents/agents-route.test.ts src/app/api/tasks/tasks-route.test.ts src/app/api/tasks/task-workspace-route.test.ts src/app/api/chats/chat-route.test.ts src/app/api/chats/clear-route.test.ts src/app/api/chats/compact-route.test.ts src/app/api/chats/context-status-route.test.ts src/app/api/connectors/connector-doctor-route.test.ts src/app/api/extensions/managed-resources/route.test.ts src/app/api/healthz/route.test.ts src/app/api/logs/route.test.ts src/app/api/portability/export/route.test.ts src/app/api/portability/import/route.test.ts src/app/api/providers/[id]/route.test.ts src/app/api/schedules/schedule-history-route.test.ts src/app/api/tts/route.test.ts",
     "test:builder": "tsx --test src/features/protocols/builder/utils/nodes-to-template.test.ts src/features/protocols/builder/utils/template-to-nodes.test.ts src/features/protocols/builder/validators/dag-validator.test.ts",
     "test:e2e": "node --import tsx scripts/browser-e2e-smoke.ts",
     "test:mcp:conformance": "node --import tsx ./scripts/mcp-conformance-check.ts",

package/src/app/api/quality/architecture-health/route.ts

@@ -0,0 +1,16 @@
+import { NextResponse } from 'next/server'
+import { buildArchitectureHealthReport } from '@/lib/quality/architecture-health'
+import { errorMessage } from '@/lib/shared-utils'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  try {
+    return NextResponse.json(buildArchitectureHealthReport())
+  } catch (err: unknown) {
+    return NextResponse.json(
+      { error: errorMessage(err) },
+      { status: 500 },
+    )
+  }
+}

package/src/app/api/quality/release-readiness/route.ts

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server'
 import { evaluateEvalGate } from '@/lib/server/eval/baseline'
 import { getOperationPulse, normalizeOperationPulseRange } from '@/lib/server/operations/operation-pulse'
+import { buildArchitectureHealthReport } from '@/lib/quality/architecture-health'
 import { buildReleaseReadinessReport } from '@/lib/quality/release-readiness'
 import { errorMessage } from '@/lib/shared-utils'
 
@@ -28,7 +29,11 @@ export async function GET(req: Request) {
       })
       : null
 
-    return NextResponse.json(buildReleaseReadinessReport({ pulse, evalGate }))
+    return NextResponse.json(buildReleaseReadinessReport({
+      pulse,
+      evalGate,
+      architectureHealth: buildArchitectureHealthReport(),
+    }))
   } catch (err: unknown) {
     return NextResponse.json(
       { error: errorMessage(err) },

package/src/cli/index.js

@@ -211,6 +211,7 @@ const COMMAND_GROUPS = [
     commands: [
       cmd('pulse', 'GET', '/operations/pulse', 'Get Operations Pulse summary (use --query range=24h or --query range=7d)'),
       cmd('readiness', 'GET', '/quality/release-readiness', 'Get release readiness report (use --query agentId=... and --query suite=core for eval gate coverage)'),
+      cmd('architecture-health', 'GET', '/quality/architecture-health', 'Get architecture health inventory and drift report'),
     ],
   },
   {

package/src/components/quality/quality-workspace.tsx

@@ -15,6 +15,7 @@ import {
   summarizeEvalRuns,
   summarizeRunHealth,
 } from '@/lib/quality/quality-summary'
+import type { ArchitectureHealthReport, ArchitectureHealthStatus } from '@/lib/quality/architecture-health'
 import type { ReleaseReadinessReport, ReleaseReadinessStatus } from '@/lib/quality/release-readiness'
 import { cn } from '@/lib/utils'
 import { useAppStore } from '@/stores/use-app-store'
@@ -142,6 +143,18 @@ function readinessScoreTone(status: ReleaseReadinessStatus): string {
   return 'text-rose-300'
 }
 
+function architectureStatusClass(status: ArchitectureHealthStatus): string {
+  if (status === 'healthy') return 'border-emerald-500/25 bg-emerald-500/10 text-emerald-200'
+  if (status === 'watch') return 'border-amber-500/25 bg-amber-500/10 text-amber-200'
+  return 'border-rose-500/25 bg-rose-500/10 text-rose-200'
+}
+
+function architectureScoreTone(status: ArchitectureHealthStatus): string {
+  if (status === 'healthy') return 'text-emerald-300'
+  if (status === 'watch') return 'text-amber-300'
+  return 'text-rose-300'
+}
+
 function ReleaseReadinessPanel({
   report,
   loading,
@@ -254,6 +267,118 @@ function ReleaseReadinessPanel({
   )
 }
 
+function ArchitectureHealthPanel({
+  report,
+  loading,
+  onRefresh,
+  onOpenHref,
+}: {
+  report: ArchitectureHealthReport | null
+  loading: boolean
+  onRefresh: () => void
+  onOpenHref: (href: string) => void
+}) {
+  return (
+    <section className="rounded-[16px] border border-white/[0.06] bg-white/[0.025] p-4">
+      <div className="flex flex-col gap-3 lg:flex-row lg:items-start lg:justify-between">
+        <div>
+          <div className="text-[11px] font-700 uppercase tracking-[0.12em] text-accent-bright/70">Architecture Health</div>
+          <h2 className="mt-1 font-display text-[17px] font-700 text-text">Runtime ownership map</h2>
+          <p className="mt-1 max-w-[680px] text-[12px] leading-relaxed text-text-3/65">
+            Inventories dispatch, memory, startup, and quality surfaces with owners, guardrails, and test evidence.
+          </p>
+        </div>
+        <button
+          type="button"
+          onClick={onRefresh}
+          disabled={loading}
+          className="shrink-0 rounded-[10px] border border-white/[0.08] bg-white/[0.04] px-3 py-2 text-[12px] font-800 text-text-2 transition-colors hover:bg-white/[0.08] disabled:opacity-40"
+        >
+          {loading ? 'Checking' : 'Refresh map'}
+        </button>
+      </div>
+
+      {!report ? (
+        <div className="mt-4 rounded-[12px] border border-dashed border-white/[0.08] bg-white/[0.02] px-4 py-5 text-[12px] text-text-3/65">
+          {loading ? 'Building architecture health report...' : 'No architecture health report is available yet.'}
+        </div>
+      ) : (
+        <div className="mt-4 grid gap-4 xl:grid-cols-[260px_1fr]">
+          <div className="rounded-[14px] border border-white/[0.06] bg-white/[0.025] p-4">
+            <span className={cn('inline-flex rounded-full border px-2.5 py-1 text-[10px] font-800 uppercase tracking-[0.1em]', architectureStatusClass(report.status))}>
+              {report.status}
+            </span>
+            <div className={cn('mt-4 font-display text-[42px] font-700 tracking-[-0.04em]', architectureScoreTone(report.status))}>{report.score}</div>
+            <div className="mt-1 text-[12px] text-text-3/65">health score</div>
+            <div className="mt-4 grid grid-cols-2 gap-2">
+              <div className="rounded-[10px] bg-white/[0.035] px-3 py-2">
+                <div className="text-[10px] font-700 uppercase tracking-[0.1em] text-text-3/50">Surfaces</div>
+                <div className="mt-1 text-[18px] font-800 text-text">{report.surfaceCount}</div>
+              </div>
+              <div className="rounded-[10px] bg-white/[0.035] px-3 py-2">
+                <div className="text-[10px] font-700 uppercase tracking-[0.1em] text-text-3/50">Guardrails</div>
+                <div className="mt-1 text-[18px] font-800 text-text">{report.guardrailCount}</div>
+              </div>
+            </div>
+          </div>
+
+          <div className="grid gap-3 lg:grid-cols-2">
+            <div className="rounded-[14px] border border-white/[0.06] bg-white/[0.02] p-3">
+              <div className="text-[12px] font-800 text-text">Domains</div>
+              <div className="mt-3 grid gap-2">
+                {report.domains.map((domain) => (
+                  <div key={domain.id} className="rounded-[10px] border border-white/[0.06] bg-white/[0.025] px-3 py-2">
+                    <div className="flex items-center justify-between gap-2">
+                      <div className="text-[12px] font-800 text-text">{domain.title}</div>
+                      <span className={cn('rounded-full border px-2 py-0.5 text-[9px] font-800 uppercase tracking-[0.08em]', architectureStatusClass(domain.status))}>
+                        {domain.status}
+                      </span>
+                    </div>
+                    <div className="mt-1 text-[11px] leading-relaxed text-text-3/65">{domain.surfaces.length} surfaces, {domain.testPaths.length} evidence paths</div>
+                  </div>
+                ))}
+              </div>
+            </div>
+
+            <div className="rounded-[14px] border border-white/[0.06] bg-white/[0.02] p-3">
+              <div className="text-[12px] font-800 text-text">Checks</div>
+              <div className="mt-3 flex flex-col gap-2">
+                {report.nextActions.length === 0 ? (
+                  report.checks.filter((check) => check.status === 'healthy').slice(0, 4).map((check) => (
+                    <button
+                      key={check.code}
+                      type="button"
+                      onClick={() => check.href && onOpenHref(check.href)}
+                      className="rounded-[10px] border border-emerald-500/20 bg-emerald-500/[0.05] px-3 py-2 text-left text-emerald-200 transition-colors hover:bg-emerald-500/[0.08]"
+                    >
+                      <div className="text-[11px] font-800 uppercase tracking-[0.08em]">{check.status}</div>
+                      <div className="mt-1 text-[12px] font-700 text-text">{check.title}</div>
+                      <div className="mt-0.5 text-[11px] leading-relaxed text-text-3/70">{check.summary}</div>
+                    </button>
+                  ))
+                ) : (
+                  report.nextActions.slice(0, 5).map((action) => (
+                    <button
+                      key={action.id}
+                      type="button"
+                      onClick={() => onOpenHref(action.href)}
+                      className={cn('rounded-[10px] border px-3 py-2 text-left transition-colors hover:bg-white/[0.08]', architectureStatusClass(action.severity))}
+                    >
+                      <div className="text-[11px] font-800 uppercase tracking-[0.08em]">{action.severity}</div>
+                      <div className="mt-1 text-[12px] font-700 text-text">{action.title}</div>
+                      <div className="mt-0.5 text-[11px] leading-relaxed text-text-3/70">{action.summary}</div>
+                    </button>
+                  ))
+                )}
+              </div>
+            </div>
+          </div>
+        </div>
+      )}
+    </section>
+  )
+}
+
 function EvalEnvironmentPanel({ plan, loading, onRefresh }: {
   plan: EvalEnvironmentPlan | null
   loading: boolean
@@ -471,6 +596,8 @@ export function QualityWorkspace() {
   const [evalBaselineBusy, setEvalBaselineBusy] = useState(false)
   const [releaseReadiness, setReleaseReadiness] = useState<ReleaseReadinessReport | null>(null)
   const [releaseReadinessLoading, setReleaseReadinessLoading] = useState(false)
+  const [architectureHealth, setArchitectureHealth] = useState<ArchitectureHealthReport | null>(null)
+  const [architectureHealthLoading, setArchitectureHealthLoading] = useState(false)
   const [approvalBusy, setApprovalBusy] = useState<string | null>(null)
 
   useEffect(() => {
@@ -578,10 +705,27 @@ export function QualityWorkspace() {
     }
   }, [evalGateScope, selectedAgentId, selectedScenarioId, selectedSuite])
 
+  const loadArchitectureHealth = useCallback(async () => {
+    setArchitectureHealthLoading(true)
+    try {
+      const report = await api<ArchitectureHealthReport>('GET', '/quality/architecture-health')
+      setArchitectureHealth(report)
+    } catch (err) {
+      setArchitectureHealth(null)
+      toast.error(err instanceof Error ? err.message : 'Unable to check architecture health')
+    } finally {
+      setArchitectureHealthLoading(false)
+    }
+  }, [])
+
   useEffect(() => {
     void loadQualityData()
   }, [loadQualityData])
 
+  useEffect(() => {
+    void loadArchitectureHealth()
+  }, [loadArchitectureHealth])
+
   useWs('runs', () => { void loadQualityData({ silent: true }) }, 5000)
 
   useEffect(() => {
@@ -746,7 +890,11 @@ export function QualityWorkspace() {
               {refreshing && <span className="text-[11px] text-text-3/60">Refreshing...</span>}
               <button
                 type="button"
-                onClick={() => void loadQualityData({ silent: true })}
+                onClick={() => {
+                  void loadQualityData({ silent: true })
+                  void loadArchitectureHealth()
+                  void loadReleaseReadiness()
+                }}
                 className="inline-flex items-center gap-2 rounded-[10px] border border-white/[0.08] bg-white/[0.04] px-3 py-2 text-[12px] font-700 text-text-2 transition-colors hover:bg-white/[0.08]"
               >
                 <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round">
@@ -790,6 +938,12 @@ export function QualityWorkspace() {
                 onRefresh={() => void loadReleaseReadiness()}
                 onOpenHref={(href) => router.push(href)}
               />
+              <ArchitectureHealthPanel
+                report={architectureHealth}
+                loading={architectureHealthLoading}
+                onRefresh={() => void loadArchitectureHealth()}
+                onOpenHref={(href) => router.push(href)}
+              />
 
               <div className="grid gap-3 md:grid-cols-2 xl:grid-cols-4">
                 <StatTile

package/src/lib/quality/architecture-health.test.ts

@@ -0,0 +1,79 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import {
+  buildArchitectureHealthReport,
+  DEFAULT_ARCHITECTURE_HEALTH_INVENTORY,
+} from './architecture-health'
+
+describe('architecture health report', () => {
+  it('summarizes the default runtime architecture inventory', () => {
+    const report = buildArchitectureHealthReport({
+      generatedAt: 100_000,
+    })
+
+    assert.equal(report.generatedAt, 100_000)
+    assert.equal(report.status, 'healthy')
+    assert.equal(report.score, 100)
+    assert.equal(report.domainCount, DEFAULT_ARCHITECTURE_HEALTH_INVENTORY.length)
+    assert.ok(report.surfaceCount >= 10)
+    assert.ok(report.guardrailCount >= 8)
+    assert.ok(report.checks.some((check) => check.code === 'dispatch_guardrail_coverage'))
+    assert.ok(report.checks.some((check) => check.code === 'memory_authority'))
+    assert.ok(report.checks.some((check) => check.code === 'startup_surface_inventory'))
+  })
+
+  it('warns when a domain has an unguarded surface', () => {
+    const report = buildArchitectureHealthReport({
+      generatedAt: 100_000,
+      inventory: [{
+        id: 'dispatch',
+        title: 'Dispatch',
+        summary: 'Test dispatch surface',
+        owner: 'runtime',
+        surfaces: [{
+          id: 'direct',
+          title: 'Direct run',
+          kind: 'dispatch',
+          path: 'src/lib/server/test.ts',
+          description: 'A dispatch path without a guardrail.',
+          guardrails: [],
+          evidence: ['No policy attached'],
+        }],
+        testPaths: ['src/lib/server/test.test.ts'],
+      }],
+    })
+
+    assert.equal(report.status, 'watch')
+    assert.ok(report.score < 100)
+    assert.equal(report.warningCount, 1)
+    assert.ok(report.checks.some((check) => check.code === 'dispatch_unguarded_surface'))
+  })
+
+  it('marks missing test coverage as an architecture risk', () => {
+    const report = buildArchitectureHealthReport({
+      generatedAt: 100_000,
+      inventory: [{
+        id: 'startup',
+        title: 'Startup',
+        summary: 'Startup entry points',
+        owner: 'runtime',
+        surfaces: [{
+          id: 'cli',
+          title: 'CLI',
+          kind: 'startup',
+          path: 'src/cli/index.js',
+          description: 'CLI startup surface.',
+          guardrails: ['route coverage'],
+          evidence: ['CLI starts the server'],
+        }],
+        testPaths: [],
+      }],
+    })
+
+    assert.equal(report.status, 'risk')
+    assert.ok(report.score <= 70)
+    assert.equal(report.riskCount, 1)
+    assert.ok(report.checks.some((check) => check.code === 'startup_missing_tests'))
+  })
+})

package/src/lib/quality/architecture-health.ts

@@ -0,0 +1,451 @@
+export type ArchitectureHealthStatus = 'healthy' | 'watch' | 'risk'
+
+export type ArchitectureSurfaceKind =
+  | 'dispatch'
+  | 'memory'
+  | 'startup'
+  | 'quality'
+
+export interface ArchitectureHealthSurface {
+  id: string
+  title: string
+  kind: ArchitectureSurfaceKind
+  path: string
+  description: string
+  guardrails: string[]
+  evidence: string[]
+}
+
+export interface ArchitectureHealthDomainInput {
+  id: string
+  title: string
+  summary: string
+  owner: string
+  surfaces: ArchitectureHealthSurface[]
+  testPaths: string[]
+}
+
+export interface ArchitectureHealthCheck {
+  code: string
+  status: ArchitectureHealthStatus
+  title: string
+  summary: string
+  evidence?: string[]
+  href?: string
+}
+
+export interface ArchitectureHealthDomain extends ArchitectureHealthDomainInput {
+  status: ArchitectureHealthStatus
+  score: number
+  checkCodes: string[]
+}
+
+export interface ArchitectureHealthAction {
+  id: string
+  severity: Exclude<ArchitectureHealthStatus, 'healthy'>
+  title: string
+  summary: string
+  href: string
+  evidence: string[]
+}
+
+export interface ArchitectureHealthReport {
+  generatedAt: number
+  status: ArchitectureHealthStatus
+  score: number
+  domainCount: number
+  surfaceCount: number
+  guardrailCount: number
+  riskCount: number
+  warningCount: number
+  domains: ArchitectureHealthDomain[]
+  checks: ArchitectureHealthCheck[]
+  nextActions: ArchitectureHealthAction[]
+}
+
+const WATCH_PENALTY = 10
+const RISK_PENALTY = 30
+
+export const DEFAULT_ARCHITECTURE_HEALTH_INVENTORY: ArchitectureHealthDomainInput[] = [
+  {
+    id: 'dispatch',
+    title: 'Dispatch Boundaries',
+    summary: 'Agent, task, protocol, connector, and tool execution paths that can start model or tool work.',
+    owner: 'runtime',
+    surfaces: [
+      {
+        id: 'agent-loop',
+        title: 'Agent loop dispatch',
+        kind: 'dispatch',
+        path: 'src/lib/server/agents/main-agent-loop.ts',
+        description: 'Main chat and autonomous run loop for agent turns.',
+        guardrails: ['tool capability policy', 'approval hooks', 'mission budgets', 'structured internal payload stripping'],
+        evidence: ['WorkingStatePatchSchema', 'MessageClassificationSchema', 'ResponseCompletenessSchema'],
+      },
+      {
+        id: 'protocol-runs',
+        title: 'Protocol run dispatch',
+        kind: 'dispatch',
+        path: 'src/lib/server/protocols/protocol-service.ts',
+        description: 'Visual protocol runner, DAG lifecycle, and step processors.',
+        guardrails: ['DAG validation', 'run lifecycle repository', 'step output contracts'],
+        evidence: ['protocol-service.test.ts', 'protocol-normalization.test.ts', 'protocol-foreach.test.ts'],
+      },
+      {
+        id: 'task-execution',
+        title: 'Task execution dispatch',
+        kind: 'dispatch',
+        path: 'src/lib/server/tasks/task-service.ts',
+        description: 'Task creation, execution workspace, liveness, handoff, and quality gates.',
+        guardrails: ['task execution policy', 'task quality gate', 'handoff packet readiness checks'],
+        evidence: ['task-execution-policy.test.ts', 'task-validation.test.ts', 'task-handoff.test.ts'],
+      },
+      {
+        id: 'connector-ingress',
+        title: 'Connector ingress dispatch',
+        kind: 'dispatch',
+        path: 'src/lib/server/connectors/connector-service.ts',
+        description: 'Inbound connector messages routed into sessions or rooms.',
+        guardrails: ['connector schema validation', 'readiness checks', 'routing tests'],
+        evidence: ['connector-routing.test.ts', 'email.test.ts', 'filequeue.test.ts'],
+      },
+      {
+        id: 'session-tools',
+        title: 'Session tool dispatch',
+        kind: 'dispatch',
+        path: 'src/lib/server/session-tools.ts',
+        description: 'Tool registry, session tool execution, and managed tool surfaces.',
+        guardrails: ['zod tool schemas', 'capability router', 'approval matching'],
+        evidence: ['tool-capability-policy.test.ts', 'universal-tool-access.test.ts', 'manage-tasks.test.ts'],
+      },
+    ],
+    testPaths: [
+      'src/lib/server/agents/agent-runtime-config.test.ts',
+      'src/lib/server/protocols/protocol-service.test.ts',
+      'src/lib/server/tasks/task-execution-policy.test.ts',
+      'src/lib/server/connectors/connector-routing.test.ts',
+      'src/lib/server/tool-capability-policy.test.ts',
+    ],
+  },
+  {
+    id: 'memory',
+    title: 'Memory Ownership',
+    summary: 'Authoritative working state, long-term memory, graph retrieval, and archive surfaces.',
+    owner: 'memory',
+    surfaces: [
+      {
+        id: 'working-state',
+        title: 'Working state service',
+        kind: 'memory',
+        path: 'src/lib/server/working-state/service.ts',
+        description: 'Structured short-term state and fact extraction for active sessions.',
+        guardrails: ['zod schemas', 'normalization', 'repository boundary'],
+        evidence: ['working-state/service.test.ts', 'working-state/extraction.ts'],
+      },
+      {
+        id: 'memory-policy',
+        title: 'Memory policy',
+        kind: 'memory',
+        path: 'src/lib/server/memory/memory-policy.ts',
+        description: 'Controls what can be written, retained, consolidated, and recalled.',
+        guardrails: ['policy tests', 'session memory scope', 'temporal decay'],
+        evidence: ['memory-policy.test.ts', 'session-memory-scope.test.ts'],
+      },
+      {
+        id: 'memory-graph',
+        title: 'Memory graph',
+        kind: 'memory',
+        path: 'src/lib/server/memory/memory-graph.ts',
+        description: 'Graph relationships and retrieval context for long-running work.',
+        guardrails: ['graph tests', 'memory retrieval tests', 'MMR ranking'],
+        evidence: ['memory-graph.test.ts', 'memory-retrieval.test.ts'],
+      },
+      {
+        id: 'session-archive',
+        title: 'Session archive memory',
+        kind: 'memory',
+        path: 'src/lib/server/memory/session-archive-memory.ts',
+        description: 'Archived session memory used after compaction or long-running autonomous work.',
+        guardrails: ['archive tests', 'freshness boundaries', 'session ownership'],
+        evidence: ['session-archive-memory.test.ts', 'memory-consolidation.test.ts'],
+      },
+    ],
+    testPaths: [
+      'src/lib/server/working-state/service.test.ts',
+      'src/lib/server/memory/memory-policy.test.ts',
+      'src/lib/server/memory/memory-graph.test.ts',
+      'src/lib/server/memory/session-archive-memory.test.ts',
+    ],
+  },
+  {
+    id: 'startup',
+    title: 'Startup Entry Points',
+    summary: 'CLI, web, desktop, daemon, and packaging paths that bootstrap the runtime.',
+    owner: 'platform',
+    surfaces: [
+      {
+        id: 'cli-server',
+        title: 'CLI server entry',
+        kind: 'startup',
+        path: 'src/cli/index.ts',
+        description: 'Package CLI, command routing, server start, and API command coverage.',
+        guardrails: ['API route coverage guard', 'binary router tests', 'pack dry run'],
+        evidence: ['src/cli/index.test.js', 'bin/swarmclaw.js'],
+      },
+      {
+        id: 'next-app',
+        title: 'Next app runtime',
+        kind: 'startup',
+        path: 'src/app',
+        description: 'Self-hosted web UI and API routes.',
+        guardrails: ['health route', 'browser smoke', 'type-check'],
+        evidence: ['healthz/route.test.ts', 'scripts/browser-e2e-smoke.ts'],
+      },
+      {
+        id: 'desktop-wrapper',
+        title: 'Desktop wrapper',
+        kind: 'startup',
+        path: 'electron/main.ts',
+        description: 'Electron wrapper around the standalone server with app-owned data directories.',
+        guardrails: ['local-only bind host', 'userData home root', 'native module rebuild smoke'],
+        evidence: ['scripts/build-electron.mjs', 'scripts/electron-after-pack.test.mjs'],
+      },
+      {
+        id: 'daemon',
+        title: 'Daemon lifecycle',
+        kind: 'startup',
+        path: 'src/app/api/daemon/route.ts',
+        description: 'Runtime daemon start, stop, health checks, and status paths.',
+        guardrails: ['daemon health check', 'safe action schema', 'CLI mapping'],
+        evidence: ['src/cli/index.test.js', 'src/app/api/daemon/health-check/route.ts'],
+      },
+    ],
+    testPaths: [
+      'src/cli/index.test.js',
+      'src/app/api/healthz/route.test.ts',
+      'scripts/electron-after-pack.test.mjs',
+      'scripts/browser-e2e-smoke.ts',
+    ],
+  },
+  {
+    id: 'quality',
+    title: 'Quality Evidence',
+    summary: 'Operator evidence surfaces that turn runtime state into release decisions.',
+    owner: 'quality',
+    surfaces: [
+      {
+        id: 'release-readiness',
+        title: 'Release readiness',
+        kind: 'quality',
+        path: 'src/lib/quality/release-readiness.ts',
+        description: 'Combines eval gates, operations pulse, approvals, budgets, and runtime readiness.',
+        guardrails: ['scored report', 'blocker and warning counts', 'next actions'],
+        evidence: ['release-readiness.test.ts', '/api/quality/release-readiness'],
+      },
+      {
+        id: 'operations-pulse',
+        title: 'Operations pulse',
+        kind: 'quality',
+        path: 'src/lib/server/operations/operation-pulse.ts',
+        description: 'Shared triage queue for failed runs, approvals, connectors, gateways, and budgets.',
+        guardrails: ['range normalization', 'severity ranking', 'operator hrefs'],
+        evidence: ['operation-pulse.test.ts', '/api/operations/pulse'],
+      },
+      {
+        id: 'eval-gates',
+        title: 'Eval regression gates',
+        kind: 'quality',
+        path: 'src/lib/server/eval/baseline.ts',
+        description: 'Compares latest eval evidence against thresholds and approved baselines.',
+        guardrails: ['baseline scope', 'regression thresholds', 'CLI commands'],
+        evidence: ['baseline.test.ts', '/api/eval/gate'],
+      },
+    ],
+    testPaths: [
+      'src/lib/quality/release-readiness.test.ts',
+      'src/lib/server/operations/operation-pulse.test.ts',
+      'src/lib/server/eval/baseline.test.ts',
+    ],
+  },
+]
+
+function worstStatus(statuses: ArchitectureHealthStatus[]): ArchitectureHealthStatus {
+  if (statuses.includes('risk')) return 'risk'
+  if (statuses.includes('watch')) return 'watch'
+  return 'healthy'
+}
+
+function statusPenalty(status: ArchitectureHealthStatus): number {
+  if (status === 'risk') return RISK_PENALTY
+  if (status === 'watch') return WATCH_PENALTY
+  return 0
+}
+
+function scoreFromChecks(checks: ArchitectureHealthCheck[]): number {
+  const penalty = checks.reduce((sum, check) => sum + statusPenalty(check.status), 0)
+  return Math.max(0, 100 - penalty)
+}
+
+function domainScore(checks: ArchitectureHealthCheck[]): number {
+  const actionable = checks.filter((check) => check.status !== 'healthy')
+  return scoreFromChecks(actionable)
+}
+
+function addCheck(checks: ArchitectureHealthCheck[], check: ArchitectureHealthCheck): void {
+  checks.push(check)
+}
+
+function plural(count: number, singular: string, pluralLabel = `${singular}s`): string {
+  return `${count} ${count === 1 ? singular : pluralLabel}`
+}
+
+function buildDomainChecks(domain: ArchitectureHealthDomainInput): ArchitectureHealthCheck[] {
+  const checks: ArchitectureHealthCheck[] = []
+
+  if (!domain.owner.trim()) {
+    addCheck(checks, {
+      code: `${domain.id}_missing_owner`,
+      status: 'risk',
+      title: `${domain.title} needs an owner`,
+      summary: 'This architecture domain does not declare an owner.',
+      evidence: [domain.id],
+    })
+  }
+
+  if (domain.surfaces.length === 0) {
+    addCheck(checks, {
+      code: `${domain.id}_missing_surfaces`,
+      status: 'risk',
+      title: `${domain.title} has no inventoried surfaces`,
+      summary: 'A quality report cannot reason about this domain until its runtime surfaces are listed.',
+      evidence: [domain.id],
+    })
+  }
+
+  if (domain.testPaths.length === 0) {
+    addCheck(checks, {
+      code: `${domain.id}_missing_tests`,
+      status: 'risk',
+      title: `${domain.title} has no mapped test evidence`,
+      summary: 'This domain needs at least one concrete test or verifier path before it can be treated as release-ready.',
+      evidence: [domain.id],
+    })
+  }
+
+  const unguarded = domain.surfaces.filter((surface) => surface.guardrails.length === 0)
+  if (unguarded.length > 0) {
+    addCheck(checks, {
+      code: `${domain.id}_unguarded_surface`,
+      status: 'watch',
+      title: `${domain.title} has unguarded surfaces`,
+      summary: `${plural(unguarded.length, 'surface')} missing explicit guardrails.`,
+      evidence: unguarded.map((surface) => `${surface.title}: ${surface.path}`),
+    })
+  }
+
+  return checks
+}
+
+function buildCrossDomainChecks(inventory: ArchitectureHealthDomainInput[]): ArchitectureHealthCheck[] {
+  const checks: ArchitectureHealthCheck[] = []
+  const surfaces = inventory.flatMap((domain) => domain.surfaces)
+  const dispatchSurfaces = surfaces.filter((surface) => surface.kind === 'dispatch')
+  const memoryDomain = inventory.find((domain) => domain.id === 'memory')
+  const startupDomain = inventory.find((domain) => domain.id === 'startup')
+
+  if (dispatchSurfaces.length > 0 && dispatchSurfaces.every((surface) => surface.guardrails.length > 0)) {
+    addCheck(checks, {
+      code: 'dispatch_guardrail_coverage',
+      status: 'healthy',
+      title: 'Dispatch surfaces declare guardrails',
+      summary: `${plural(dispatchSurfaces.length, 'dispatch surface')} mapped to policy, approval, schema, or lifecycle controls.`,
+      evidence: dispatchSurfaces.map((surface) => `${surface.title}: ${surface.guardrails.join(', ')}`),
+      href: '/quality',
+    })
+  }
+
+  if (memoryDomain && memoryDomain.surfaces.length >= 3 && memoryDomain.testPaths.length > 0) {
+    addCheck(checks, {
+      code: 'memory_authority',
+      status: 'healthy',
+      title: 'Memory ownership is explicit',
+      summary: 'Working state, policy, graph, and archive surfaces are inventoried with test evidence.',
+      evidence: memoryDomain.surfaces.map((surface) => surface.path),
+      href: '/memory',
+    })
+  }
+
+  if (startupDomain && startupDomain.surfaces.length >= 3 && startupDomain.testPaths.length > 0) {
+    addCheck(checks, {
+      code: 'startup_surface_inventory',
+      status: 'healthy',
+      title: 'Startup surfaces are inventoried',
+      summary: 'CLI, web, desktop, and daemon entry points are tracked with smoke or route evidence.',
+      evidence: startupDomain.surfaces.map((surface) => surface.path),
+      href: '/settings',
+    })
+  }
+
+  return checks
+}
+
+function makeAction(check: ArchitectureHealthCheck): ArchitectureHealthAction | null {
+  if (check.status === 'healthy') return null
+  return {
+    id: check.code,
+    severity: check.status,
+    title: check.title,
+    summary: check.summary,
+    href: check.href || '/quality',
+    evidence: check.evidence || [],
+  }
+}
+
+export function buildArchitectureHealthReport(input: {
+  generatedAt?: number
+  inventory?: ArchitectureHealthDomainInput[]
+} = {}): ArchitectureHealthReport {
+  const generatedAt = input.generatedAt ?? Date.now()
+  const inventory = input.inventory ?? DEFAULT_ARCHITECTURE_HEALTH_INVENTORY
+  const domainChecks = new Map<string, ArchitectureHealthCheck[]>()
+  const checks: ArchitectureHealthCheck[] = []
+
+  for (const domain of inventory) {
+    const nextChecks = buildDomainChecks(domain)
+    domainChecks.set(domain.id, nextChecks)
+    checks.push(...nextChecks)
+  }
+
+  checks.push(...buildCrossDomainChecks(inventory))
+
+  const domains: ArchitectureHealthDomain[] = inventory.map((domain) => {
+    const actionableChecks = domainChecks.get(domain.id) ?? []
+    return {
+      ...domain,
+      status: worstStatus(actionableChecks.map((check) => check.status)),
+      score: domainScore(actionableChecks),
+      checkCodes: actionableChecks.map((check) => check.code),
+    }
+  })
+
+  const actionableChecks = checks.filter((check) => check.status !== 'healthy')
+  const reportStatus = worstStatus(actionableChecks.map((check) => check.status))
+  const warningCount = actionableChecks.filter((check) => check.status === 'watch').length
+  const riskCount = actionableChecks.filter((check) => check.status === 'risk').length
+
+  return {
+    generatedAt,
+    status: reportStatus,
+    score: scoreFromChecks(actionableChecks),
+    domainCount: inventory.length,
+    surfaceCount: inventory.reduce((sum, domain) => sum + domain.surfaces.length, 0),
+    guardrailCount: inventory.reduce((sum, domain) => (
+      sum + domain.surfaces.reduce((surfaceSum, surface) => surfaceSum + surface.guardrails.length, 0)
+    ), 0),
+    riskCount,
+    warningCount,
+    domains,
+    checks,
+    nextActions: actionableChecks.map(makeAction).filter((action): action is ArchitectureHealthAction => action !== null),
+  }
+}

package/src/lib/quality/release-readiness.test.ts

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict'
 import { describe, it } from 'node:test'
 
+import { buildArchitectureHealthReport } from './architecture-health'
 import { buildReleaseReadinessReport } from './release-readiness'
 import type { EvalGateResult } from '@/lib/server/eval/types'
 import type { OperationPulse } from '@/types'
@@ -126,4 +127,16 @@ describe('release readiness report', () => {
     assert.ok(report.checks.some((check) => check.code === 'failed_runs_present'))
     assert.ok(report.checks.some((check) => check.code === 'pending_approvals_present'))
   })
+
+  it('includes architecture health when supplied', () => {
+    const report = buildReleaseReadinessReport({
+      pulse: pulse(),
+      evalGate: evalGate(),
+      architectureHealth: buildArchitectureHealthReport({ generatedAt: now }),
+    })
+
+    assert.equal(report.status, 'ready')
+    assert.equal(report.architectureHealth?.status, 'healthy')
+    assert.ok(report.checks.some((check) => check.code === 'architecture_health_passed'))
+  })
 })

package/src/lib/quality/release-readiness.ts

@@ -1,4 +1,5 @@
 import type { EvalGateResult } from '@/lib/server/eval/types'
+import type { ArchitectureHealthReport } from '@/lib/quality/architecture-health'
 import type { OperationPulse, OperationPulseAction, OperationPulseRange } from '@/types'
 
 export type ReleaseReadinessStatus = 'ready' | 'warning' | 'blocked'
@@ -21,6 +22,7 @@ export interface ReleaseReadinessReport {
   warningCount: number
   pulse: OperationPulse
   evalGate: EvalGateResult | null
+  architectureHealth: ArchitectureHealthReport | null
   checks: ReleaseReadinessCheck[]
   nextActions: OperationPulseAction[]
 }
@@ -54,9 +56,11 @@ function addCheck(checks: ReleaseReadinessCheck[], check: ReleaseReadinessCheck)
 export function buildReleaseReadinessReport(input: {
   pulse: OperationPulse
   evalGate?: EvalGateResult | null
+  architectureHealth?: ArchitectureHealthReport | null
 }): ReleaseReadinessReport {
   const checks: ReleaseReadinessCheck[] = []
   const evalGate = input.evalGate ?? null
+  const architectureHealth = input.architectureHealth ?? null
 
   if (!evalGate) {
     addCheck(checks, {
@@ -169,6 +173,37 @@ export function buildReleaseReadinessReport(input: {
     })
   }
 
+  if (architectureHealth) {
+    if (architectureHealth.status === 'risk') {
+      addCheck(checks, {
+        code: 'architecture_health_risk',
+        status: 'blocked',
+        title: 'Architecture health has risks',
+        summary: `${plural(architectureHealth.riskCount, 'architecture risk')} need review before release.`,
+        href: '/quality',
+        evidence: architectureHealth.nextActions.map((action) => action.summary),
+      })
+    } else if (architectureHealth.status === 'watch') {
+      addCheck(checks, {
+        code: 'architecture_health_watch',
+        status: 'warning',
+        title: 'Architecture health needs review',
+        summary: `${plural(architectureHealth.warningCount, 'architecture warning')} found in runtime ownership checks.`,
+        href: '/quality',
+        evidence: architectureHealth.nextActions.map((action) => action.summary),
+      })
+    } else {
+      addCheck(checks, {
+        code: 'architecture_health_passed',
+        status: 'ready',
+        title: 'Architecture health passed',
+        summary: 'Dispatch, memory, startup, and quality surfaces have mapped owners, guardrails, and test evidence.',
+        href: '/quality',
+        evidence: [`${architectureHealth.score} health score`],
+      })
+    }
+  }
+
   const blockerCount = checks.filter((check) => check.status === 'blocked').length
   const warningCount = checks.filter((check) => check.status === 'warning').length
 
@@ -181,6 +216,7 @@ export function buildReleaseReadinessReport(input: {
     warningCount,
     pulse: input.pulse,
     evalGate,
+    architectureHealth,
     checks,
     nextActions: input.pulse.actions.slice(0, 8),
   }