diff --git a/03-frontend/app/app/dev/api-lab/page.tsx b/03-frontend/app/app/dev/api-lab/page.tsx
index 838357ab..485d6710 100644
--- a/03-frontend/app/app/dev/api-lab/page.tsx
+++ b/03-frontend/app/app/dev/api-lab/page.tsx
@@ -4,7 +4,7 @@
 // License: Apache-2.0
 
 import { useState } from 'react';
-import { ARCHITOKEN_API_BASE_URL } from '@/lib/backend-api';
+import { ARCHITOKEN_API_BASE_URL, setBackendRequestContext } from '@/lib/backend-api';
 import { artifactClient, type Artifact } from '@/lib/artifact-client';
 import { generationClient, type GenerationJob } from '@/lib/generation-client';
 import {
@@ -20,12 +20,16 @@ type RunState = 'idle' | 'loading' | 'error';
 
 function describeError(error: unknown): string {
   if (typeof error === 'object' && error !== null && 'error' in error) {
-    return String((error as { error: unknown }).error);
+    return JSON.stringify(error, null, 2);
   }
   return error instanceof Error ? error.message : String(error);
 }
 
 export default function ApiLabPage() {
+  const [tenantId, setTenantId] = useState('dev-tenant');
+  const [projectId, setProjectId] = useState('dev-project');
+  const [actor, setActor] = useState('frontend-api-lab');
+  const [rolesText, setRolesText] = useState('admin');
   const [capabilities, setCapabilities] = useState<RuntimeCapabilities | null>(null);
   const [job, setJob] = useState<GenerationJob | null>(null);
   const [artifacts, setArtifacts] = useState<Artifact[]>([]);
@@ -38,7 +42,22 @@ export default function ApiLabPage() {
     setLog((current) => [`${new Date().toISOString()} ${message}`, ...current].slice(0, 12));
   };
 
+  const applyContext = () => {
+    setBackendRequestContext({
+      tenantId,
+      projectId,
+      actor,
+      roles: rolesText
+        .split(',')
+        .map((role) => role.trim())
+        .filter(Boolean),
+      requestId: `api-lab-${actor}`,
+      correlationId: `api-lab-${tenantId}-${projectId}`,
+    });
+  };
+
   const loadCapabilities = async () => {
+    applyContext();
     setRunState('loading');
     setErrorMessage(null);
     try {
@@ -55,6 +74,7 @@ export default function ApiLabPage() {
   };
 
   const runGenerationSequence = async () => {
+    applyContext();
     setRunState('loading');
     setErrorMessage(null);
     try {
@@ -62,31 +82,31 @@ export default function ApiLabPage() {
         moduleId: 'digital_twin',
         mode: 'model_to_lightweight_scene',
         prompt: 'Create a local preview lightweight scene with property index and identity map.',
-        actor: 'frontend-api-lab',
+        actor,
       });
       appendLog(`job created: ${created.id}`);
 
       const planned = await generationClient.plan(created.id, {
-        actor: 'frontend-api-lab',
+        actor,
         comment: 'plan from API lab',
       });
       appendLog(`job planned: ${planned.status}`);
 
       const run = await generationClient.run(planned.id, {
-        actor: 'frontend-api-lab',
+        actor,
         comment: 'run local mock generator',
       });
       appendLog(`job run: ${run.status}`);
 
       const reviewed = await generationClient.review(run.id, {
-        reviewer: 'frontend-api-lab',
+        reviewer: actor,
         decision: 'approved',
         comment: 'review accepted in API lab',
       });
       appendLog(`job reviewed: ${reviewed.status}`);
 
       const approved = await generationClient.approve(reviewed.id, {
-        actor: 'frontend-api-lab',
+        actor,
         comment: 'approve generated preview artifacts',
       });
       setJob(approved);
@@ -105,6 +125,7 @@ export default function ApiLabPage() {
   };
 
   const submitViewerCommand = async () => {
+    applyContext();
     const artifact = artifacts[0];
     if (!artifact) {
       appendLog('viewer command skipped: run generation first');
@@ -120,12 +141,12 @@ export default function ApiLabPage() {
         artifactId: artifact.id,
         elementIds: ['architoken:demo:001'],
         arguments: { color: '#ff6600' },
-        actor: 'frontend-api-lab',
+        actor,
       });
       appendLog(`viewer command created: ${created.id}`);
 
       const acked = await viewerCommandClient.ack(created.id, {
-        actor: 'frontend-api-lab',
+        actor,
         status: 'executed',
         comment: 'dev console executed command contract',
         result: { rendered: false, backendContractOnly: true },
@@ -146,7 +167,7 @@ export default function ApiLabPage() {
       <section className="mx-auto flex max-w-6xl flex-col gap-6">
         <header className="arch-surface rounded-[var(--arch-radius)] border p-6">
           <p className="arch-muted text-sm uppercase tracking-[0.24em]">
-            Phase 5 Runtime Persistence E2E
+            Phase 6 Durable Store + RBAC
           </p>
           <h1 className="mt-2 text-3xl font-semibold">Backend API Lab</h1>
           <p className="arch-muted mt-3 max-w-3xl">
@@ -156,6 +177,48 @@ export default function ApiLabPage() {
           <p className="mt-3 font-mono text-sm">API base: {ARCHITOKEN_API_BASE_URL}</p>
         </header>
 
+        <section className="arch-surface rounded-[var(--arch-radius)] border p-5">
+          <h2 className="text-xl font-semibold">Request Context</h2>
+          <div className="mt-4 grid gap-3 md:grid-cols-4">
+            <label className="text-sm">
+              <span className="arch-muted block">Tenant</span>
+              <input
+                className="mt-1 w-full rounded-xl border px-3 py-2 text-black"
+                value={tenantId}
+                onChange={(event) => setTenantId(event.target.value)}
+              />
+            </label>
+            <label className="text-sm">
+              <span className="arch-muted block">Project</span>
+              <input
+                className="mt-1 w-full rounded-xl border px-3 py-2 text-black"
+                value={projectId}
+                onChange={(event) => setProjectId(event.target.value)}
+              />
+            </label>
+            <label className="text-sm">
+              <span className="arch-muted block">Actor</span>
+              <input
+                className="mt-1 w-full rounded-xl border px-3 py-2 text-black"
+                value={actor}
+                onChange={(event) => setActor(event.target.value)}
+              />
+            </label>
+            <label className="text-sm">
+              <span className="arch-muted block">Roles</span>
+              <input
+                className="mt-1 w-full rounded-xl border px-3 py-2 text-black"
+                value={rolesText}
+                onChange={(event) => setRolesText(event.target.value)}
+              />
+            </label>
+          </div>
+          <p className="arch-muted mt-3 text-sm">
+            Requests send X-Tenant-Id, X-Project-Id, X-Actor, X-Roles, X-Request-Id, and
+            X-Correlation-Id headers through the shared backend-api client.
+          </p>
+        </section>
+
         <div className="grid gap-4 md:grid-cols-3">
           <button className="arch-btn rounded-2xl px-5 py-4 text-left" onClick={loadCapabilities}>
             Load runtime capabilities
@@ -174,7 +237,9 @@ export default function ApiLabPage() {
         {runState === 'error' ? (
           <div className="rounded-2xl border border-red-200 bg-red-50 p-4 text-red-700">
             <p className="font-semibold">Last API call failed.</p>
-            <p className="mt-1 text-sm">{errorMessage ?? 'Check the log and backend process.'}</p>
+            <pre className="mt-2 whitespace-pre-wrap text-sm">
+              {errorMessage ?? 'Check the log and backend process.'}
+            </pre>
           </div>
         ) : null}
 
@@ -184,6 +249,9 @@ export default function ApiLabPage() {
             <p className="arch-muted mt-2 text-sm">
               Capability status: {capabilities ? 'loaded' : runState === 'loading' ? 'loading' : 'not loaded'}
             </p>
+            <p className="arch-muted mt-2 text-sm">
+              Context: {tenantId}/{projectId} as {actor} [{rolesText}]
+            </p>
             <p className="arch-muted mt-2 text-sm">
               Modules: {capabilities?.activeModuleIds.join(', ') ?? 'not loaded'}
             </p>
@@ -192,6 +260,10 @@ export default function ApiLabPage() {
               {capabilities?.generation.artifactKinds.length ?? 0}; storage:{' '}
               {capabilities?.storage.providers.join(', ') ?? 'unknown'}
             </p>
+            <p className="arch-muted mt-2 text-sm">
+              Store boundary:{' '}
+              {capabilities?.storeCapabilities.inMemoryOnly ? 'in-memory deterministic' : 'unknown'}
+            </p>
           </article>
 
           <article className="arch-surface rounded-[var(--arch-radius)] border p-5">
diff --git a/03-frontend/lib/artifact-client.ts b/03-frontend/lib/artifact-client.ts
index 922bc88c..2616bc1b 100644
--- a/03-frontend/lib/artifact-client.ts
+++ b/03-frontend/lib/artifact-client.ts
@@ -32,11 +32,17 @@ export interface ArtifactMetadata {
   mimeType: string;
   sizeBytes: number;
   owner: string;
+  tenantId: string;
+  projectId: string;
+  version: number;
+  requestId: string;
+  correlationId: string;
   sourceJobId: string | null;
   createdByJobId: string | null;
   approvalStatus: string;
   auditEventId: string | null;
   createdAt: string;
+  updatedAt: string;
 }
 
 export interface ArtifactVersion {
diff --git a/03-frontend/lib/backend-api.ts b/03-frontend/lib/backend-api.ts
index 8f1591cf..9c0ec3da 100644
--- a/03-frontend/lib/backend-api.ts
+++ b/03-frontend/lib/backend-api.ts
@@ -6,9 +6,38 @@ export interface BackendApiError {
   code: number;
 }
 
+export interface RuntimeRequestContext {
+  tenantId: string;
+  projectId: string;
+  actor: string;
+  roles: string[];
+  requestId?: string;
+  correlationId?: string;
+}
+
 export const ARCHITOKEN_API_BASE_URL =
   process.env.NEXT_PUBLIC_ARCHITOKEN_API_BASE_URL ?? 'http://localhost:8080';
 
+let activeRequestContext: RuntimeRequestContext = {
+  tenantId: 'dev-tenant',
+  projectId: 'dev-project',
+  actor: 'frontend-api-lab',
+  roles: ['admin'],
+  requestId: 'frontend-api-lab',
+  correlationId: 'frontend-api-lab',
+};
+
+export function setBackendRequestContext(context: RuntimeRequestContext): void {
+  activeRequestContext = {
+    ...context,
+    roles: context.roles.length > 0 ? context.roles : ['admin'],
+  };
+}
+
+export function getBackendRequestContext(): RuntimeRequestContext {
+  return activeRequestContext;
+}
+
 export function buildQuery(
   params: Record<string, string | number | boolean | null | undefined>,
 ): string {
@@ -26,13 +55,24 @@ export async function backendRequest<T>(
   path: string,
   init: RequestInit = {},
 ): Promise<T> {
+  const headers = new Headers(init.headers);
+  headers.set('Accept', 'application/json');
+  if (init.body) {
+    headers.set('Content-Type', 'application/json');
+  }
+  headers.set('X-Tenant-Id', activeRequestContext.tenantId);
+  headers.set('X-Project-Id', activeRequestContext.projectId);
+  headers.set('X-Actor', activeRequestContext.actor);
+  headers.set('X-Roles', activeRequestContext.roles.join(','));
+  headers.set('X-Request-Id', activeRequestContext.requestId ?? activeRequestContext.actor);
+  headers.set(
+    'X-Correlation-Id',
+    activeRequestContext.correlationId ?? activeRequestContext.requestId ?? activeRequestContext.actor,
+  );
+
   const response = await fetch(`${ARCHITOKEN_API_BASE_URL}${path}`, {
     ...init,
-    headers: {
-      Accept: 'application/json',
-      ...(init.body ? { 'Content-Type': 'application/json' } : {}),
-      ...(init.headers ?? {}),
-    },
+    headers,
   });
 
   if (!response.ok) {
diff --git a/03-frontend/lib/generation-client.ts b/03-frontend/lib/generation-client.ts
index d256207c..700deb21 100644
--- a/03-frontend/lib/generation-client.ts
+++ b/03-frontend/lib/generation-client.ts
@@ -3,6 +3,7 @@
 
 import { backendRequest, buildQuery } from './backend-api';
 import type { Artifact } from './artifact-client';
+import type { RuntimeRequestContext } from './backend-api';
 
 export type GenerationReviewDecision = 'approved' | 'rejected' | 'needs_changes';
 
@@ -33,6 +34,9 @@ export interface GenerationJob {
   status: string;
   artifacts: Artifact[];
   lifecycleTransactionId: string | null;
+  actor: string;
+  context: RuntimeRequestContext;
+  version: number;
   createdAt: string;
   updatedAt: string;
 }
diff --git a/03-frontend/lib/runtime-capabilities.ts b/03-frontend/lib/runtime-capabilities.ts
index 5a2ff13f..6e18b56a 100644
--- a/03-frontend/lib/runtime-capabilities.ts
+++ b/03-frontend/lib/runtime-capabilities.ts
@@ -29,12 +29,25 @@ export interface RuntimeStorageCapabilities {
   productionReady: boolean;
 }
 
+export interface RuntimeStoreCapabilities {
+  objectStore: boolean;
+  transactionStore: boolean;
+  eventStore: boolean;
+  registryStore: boolean;
+  artifactStore: boolean;
+  viewerCommandStore: boolean;
+  knowledgeSourceStore: boolean;
+  inMemoryOnly: boolean;
+  deterministicPagination: boolean;
+}
+
 export interface RuntimeCapabilities {
   activeModuleIds: string[];
   generation: RuntimeGenerationCapabilities;
   viewer: RuntimeViewerCapabilities;
   registry: RuntimeRegistryCapabilities;
   storage: RuntimeStorageCapabilities;
+  storeCapabilities: RuntimeStoreCapabilities;
   localImplementationMode: 'in_memory_preview';
   productionCaveats: string[];
 }
diff --git a/03-frontend/lib/viewer-command-client.ts b/03-frontend/lib/viewer-command-client.ts
index 389db07d..b5bce336 100644
--- a/03-frontend/lib/viewer-command-client.ts
+++ b/03-frontend/lib/viewer-command-client.ts
@@ -2,6 +2,7 @@
 // License: Apache-2.0
 
 import { backendRequest, buildQuery } from './backend-api';
+import type { RuntimeRequestContext } from './backend-api';
 
 export type ViewerCommandStatus = 'queued' | 'executed' | 'skipped';
 
@@ -13,6 +14,8 @@ export interface ViewerAdapterCommand {
   elementIds: string[];
   arguments: Record<string, unknown>;
   status: ViewerCommandStatus;
+  context: RuntimeRequestContext;
+  version: number;
   auditEventId: string | null;
   acknowledgedBy: string | null;
   acknowledgedAt: string | null;
diff --git a/04-backend/harness-core/src/bin/gateway.rs b/04-backend/harness-core/src/bin/gateway.rs
index 27d59937..21b31c5b 100644
--- a/04-backend/harness-core/src/bin/gateway.rs
+++ b/04-backend/harness-core/src/bin/gateway.rs
@@ -12,8 +12,8 @@ use std::sync::Arc;
 
 use axum::{
     Json, Router,
-    extract::{Path, Query, State},
-    http::StatusCode,
+    extract::{Path, Query, RawQuery, State},
+    http::{HeaderMap, StatusCode},
     response::IntoResponse,
     routing::{get, post},
 };
@@ -56,6 +56,11 @@ use insomeos_harness_core::{
     observability,
     rollback_guard::RollbackGuard,
     runtime_capabilities::RuntimeCapabilities,
+    runtime_context::{
+        HEADER_ACTOR, HEADER_CORRELATION_ID, HEADER_PROJECT_ID, HEADER_REQUEST_ID, HEADER_ROLES,
+        HEADER_TENANT_ID, PermissionGuard, RequestContext, RequestContextInput, RuntimePermission,
+        RuntimeProfile,
+    },
     skill_registry::{
         CreateSkillRequest, RegistryActionRequest, SkillListQuery, SkillListResponse,
         SkillRegistryService, SkillSpec, UpdateSkillRequest,
@@ -79,6 +84,7 @@ struct AppState {
     knowledge_sources: KnowledgeSourceRegistryService,
     viewer_commands: ViewerCommandService,
     audit: Arc<ModuleAuditService>,
+    runtime_profile: RuntimeProfile,
 }
 
 #[derive(Debug, Serialize)]
@@ -143,6 +149,9 @@ async fn main() -> Result<()> {
     let skills = SkillRegistryService::new();
     let mcp_tools = McpToolRegistryService::new();
     let knowledge_sources = KnowledgeSourceRegistryService::new();
+    let runtime_profile = RuntimeProfile::from_profile_name(
+        &std::env::var("INSOMEOS_PROFILE").unwrap_or_else(|_| "development".to_owned()),
+    );
 
     let state = AppState {
         router,
@@ -155,6 +164,7 @@ async fn main() -> Result<()> {
         knowledge_sources,
         viewer_commands,
         audit,
+        runtime_profile,
     };
 
     let cors = CorsLayer::new()
@@ -339,8 +349,19 @@ async fn readyz(State(state): State<AppState>) -> impl IntoResponse {
     (StatusCode::OK, "ready")
 }
 
-async fn runtime_capabilities_handler() -> Json<RuntimeCapabilities> {
-    Json(RuntimeCapabilities::in_memory_preview())
+async fn runtime_capabilities_handler(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
+) -> Result<Json<RuntimeCapabilities>> {
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    PermissionGuard::ensure(&context, RuntimePermission::RegistryRead)?;
+    Ok(Json(RuntimeCapabilities::in_memory_preview()))
 }
 
 async fn list_modules_handler() -> Json<ModuleListResponse> {
@@ -357,6 +378,61 @@ async fn get_module_handler(Path(module_id): Path<String>) -> Result<Json<Module
         .ok_or_else(|| HarnessError::NotFound(format!("module_id={module_id}")))
 }
 
+fn request_context(
+    state: &AppState,
+    headers: &HeaderMap,
+    raw_query: Option<&str>,
+    body_fallback: RequestContextInput,
+) -> Result<RequestContext> {
+    let input = context_from_headers(headers)
+        .with_fallback(&context_from_query(raw_query))
+        .with_fallback(&body_fallback);
+    RequestContext::from_input(input, state.runtime_profile)
+}
+
+fn context_from_headers(headers: &HeaderMap) -> RequestContextInput {
+    RequestContextInput {
+        tenant_id: header_value(headers, HEADER_TENANT_ID),
+        project_id: header_value(headers, HEADER_PROJECT_ID),
+        actor: header_value(headers, HEADER_ACTOR),
+        roles: header_value(headers, HEADER_ROLES).map(|roles| vec![roles]),
+        request_id: header_value(headers, HEADER_REQUEST_ID),
+        correlation_id: header_value(headers, HEADER_CORRELATION_ID),
+    }
+}
+
+fn context_from_query(raw_query: Option<&str>) -> RequestContextInput {
+    let mut input = RequestContextInput::default();
+    let Some(raw_query) = raw_query else {
+        return input;
+    };
+    for pair in raw_query.split('&').filter(|pair| !pair.is_empty()) {
+        let (key, value) = pair.split_once('=').unwrap_or((pair, ""));
+        let value = value.replace('+', " ");
+        match key {
+            "tenant_id" | "tenantId" | "X-Tenant-Id" => input.tenant_id = Some(value),
+            "project_id" | "projectId" | "X-Project-Id" => input.project_id = Some(value),
+            "actor" | "X-Actor" => input.actor = Some(value),
+            "roles" | "X-Roles" => input.roles = Some(vec![value]),
+            "request_id" | "requestId" | "X-Request-Id" => input.request_id = Some(value),
+            "correlation_id" | "correlationId" | "X-Correlation-Id" => {
+                input.correlation_id = Some(value);
+            }
+            _ => {}
+        }
+    }
+    input
+}
+
+fn header_value(headers: &HeaderMap, name: &str) -> Option<String> {
+    headers
+        .get(name)
+        .and_then(|value| value.to_str().ok())
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(ToOwned::to_owned)
+}
+
 async fn list_module_files_handler(
     State(state): State<AppState>,
     Path(module_id): Path<String>,
@@ -527,9 +603,17 @@ async fn list_audit_events_handler(
 
 async fn list_generation_jobs_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Query(query): Query<GenerationJobQuery>,
 ) -> Result<Json<GenerationJobListResponse>> {
-    let page = state.generation.list_jobs(&query)?;
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    let page = state.generation.list_jobs_with_context(&context, &query)?;
     Ok(Json(GenerationJobListResponse {
         total: page.items.len(),
         jobs: page.items,
@@ -539,78 +623,191 @@ async fn list_generation_jobs_handler(
 
 async fn create_generation_job_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Json(req): Json<GenerationInput>,
 ) -> Result<(StatusCode, Json<GenerationJob>)> {
-    let job = state.generation.create_job(req)?;
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: req.actor.clone(),
+            ..RequestContextInput::default()
+        },
+    )?;
+    let job = state.generation.create_job_with_context(&context, req)?;
     Ok((StatusCode::CREATED, Json(job)))
 }
 
 async fn get_generation_job_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(job_id): Path<String>,
 ) -> Result<Json<GenerationJob>> {
     let job_id = parse_uuid(&job_id, "job_id")?;
-    state.generation.get_job(job_id).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    state
+        .generation
+        .get_job_with_context(&context, job_id)
+        .map(Json)
 }
 
 async fn plan_generation_job_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(job_id): Path<String>,
     Json(req): Json<GenerationActionRequest>,
 ) -> Result<Json<GenerationJob>> {
     let job_id = parse_uuid(&job_id, "job_id")?;
-    state.generation.plan_job(job_id, req).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: req.actor.clone(),
+            ..RequestContextInput::default()
+        },
+    )?;
+    state
+        .generation
+        .plan_job_with_context(&context, job_id, req)
+        .map(Json)
 }
 
 async fn run_generation_job_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(job_id): Path<String>,
     Json(req): Json<GenerationActionRequest>,
 ) -> Result<Json<GenerationJob>> {
     let job_id = parse_uuid(&job_id, "job_id")?;
-    state.generation.run_job(job_id, req).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: req.actor.clone(),
+            ..RequestContextInput::default()
+        },
+    )?;
+    state
+        .generation
+        .run_job_with_context(&context, job_id, req)
+        .map(Json)
 }
 
 async fn review_generation_job_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(job_id): Path<String>,
     Json(req): Json<GenerationReviewRequest>,
 ) -> Result<Json<GenerationJob>> {
     let job_id = parse_uuid(&job_id, "job_id")?;
-    state.generation.review_job(job_id, req).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: Some(req.reviewer.clone()),
+            ..RequestContextInput::default()
+        },
+    )?;
+    state
+        .generation
+        .review_job_with_context(&context, job_id, req)
+        .map(Json)
 }
 
 async fn approve_generation_job_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(job_id): Path<String>,
     Json(req): Json<GenerationActionRequest>,
 ) -> Result<Json<GenerationJob>> {
     let job_id = parse_uuid(&job_id, "job_id")?;
-    state.generation.approve_job(job_id, req).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: req.actor.clone(),
+            ..RequestContextInput::default()
+        },
+    )?;
+    state
+        .generation
+        .approve_job_with_context(&context, job_id, req)
+        .map(Json)
 }
 
 async fn reject_generation_job_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(job_id): Path<String>,
     Json(req): Json<GenerationActionRequest>,
 ) -> Result<Json<GenerationJob>> {
     let job_id = parse_uuid(&job_id, "job_id")?;
-    state.generation.reject_job(job_id, req).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: req.actor.clone(),
+            ..RequestContextInput::default()
+        },
+    )?;
+    state
+        .generation
+        .reject_job_with_context(&context, job_id, req)
+        .map(Json)
 }
 
 async fn list_generation_artifacts_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(job_id): Path<String>,
 ) -> Result<Json<GenerationArtifactsResponse>> {
     let job_id = parse_uuid(&job_id, "job_id")?;
-    state.generation.list_artifacts(job_id).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    state
+        .generation
+        .list_artifacts_with_context(&context, job_id)
+        .map(Json)
 }
 
 async fn list_artifacts_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Query(query): Query<ArtifactListQuery>,
 ) -> Result<Json<ArtifactListResponse>> {
-    let page = state.generation.list_indexed_artifacts(&query)?;
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    let page = state
+        .generation
+        .list_indexed_artifacts_with_context(&context, &query)?;
     Ok(Json(ArtifactListResponse {
         total: page.items.len(),
         artifacts: page.items,
@@ -620,50 +817,95 @@ async fn list_artifacts_handler(
 
 async fn get_artifact_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(artifact_id): Path<String>,
 ) -> Result<Json<Artifact>> {
     let artifact_id = parse_uuid(&artifact_id, "artifact_id")?;
-    state.generation.get_artifact(artifact_id).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    state
+        .generation
+        .get_artifact_with_context(&context, artifact_id)
+        .map(Json)
 }
 
 async fn get_artifact_versions_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(artifact_id): Path<String>,
 ) -> Result<Json<Vec<ArtifactVersion>>> {
     let artifact_id = parse_uuid(&artifact_id, "artifact_id")?;
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
     state
         .generation
-        .get_artifact_versions(artifact_id)
+        .get_artifact_versions_with_context(&context, artifact_id)
         .map(Json)
 }
 
 async fn get_artifact_metadata_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(artifact_id): Path<String>,
 ) -> Result<Json<ArtifactMetadata>> {
     let artifact_id = parse_uuid(&artifact_id, "artifact_id")?;
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
     state
         .generation
-        .get_artifact_metadata(artifact_id)
+        .get_artifact_metadata_with_context(&context, artifact_id)
         .map(Json)
 }
 
 async fn get_artifact_storage_binding_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(artifact_id): Path<String>,
 ) -> Result<Json<ArtifactStorageBinding>> {
     let artifact_id = parse_uuid(&artifact_id, "artifact_id")?;
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
     state
         .generation
-        .get_artifact_storage_binding(artifact_id)
+        .get_artifact_storage_binding_with_context(&context, artifact_id)
         .map(Json)
 }
 
 async fn list_viewer_commands_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Query(query): Query<ViewerCommandListQuery>,
 ) -> Result<Json<ViewerCommandListResponse>> {
-    let page = state.viewer_commands.list_commands(&query)?;
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    let page = state
+        .viewer_commands
+        .list_commands_with_context(&context, &query)?;
     Ok(Json(ViewerCommandListResponse {
         total: page.items.len(),
         commands: page.items,
@@ -673,34 +915,80 @@ async fn list_viewer_commands_handler(
 
 async fn create_viewer_command_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Json(req): Json<ViewerCommandCreateRequest>,
 ) -> Result<(StatusCode, Json<ViewerAdapterCommand>)> {
-    let command = state.viewer_commands.create_command(req)?;
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: req.actor.clone(),
+            ..RequestContextInput::default()
+        },
+    )?;
+    let command = state
+        .viewer_commands
+        .create_command_with_context(&context, req)?;
     Ok((StatusCode::CREATED, Json(command)))
 }
 
 async fn get_viewer_command_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(command_id): Path<String>,
 ) -> Result<Json<ViewerAdapterCommand>> {
     let command_id = parse_uuid(&command_id, "command_id")?;
-    state.viewer_commands.get_command(command_id).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    state
+        .viewer_commands
+        .get_command_with_context(&context, command_id)
+        .map(Json)
 }
 
 async fn ack_viewer_command_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(command_id): Path<String>,
     Json(req): Json<ViewerCommandAckRequest>,
 ) -> Result<Json<ViewerAdapterCommand>> {
     let command_id = parse_uuid(&command_id, "command_id")?;
-    state.viewer_commands.ack_command(command_id, req).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: Some(req.actor.clone()),
+            ..RequestContextInput::default()
+        },
+    )?;
+    state
+        .viewer_commands
+        .ack_command_with_context(&context, command_id, req)
+        .map(Json)
 }
 
 async fn list_skills_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Query(query): Query<SkillListQuery>,
 ) -> Result<Json<SkillListResponse>> {
-    let page = state.skills.list_skills(&query)?;
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    let page = state.skills.list_skills_with_context(&context, &query)?;
     Ok(Json(SkillListResponse {
         total: page.items.len(),
         skills: page.items,
@@ -710,48 +998,114 @@ async fn list_skills_handler(
 
 async fn create_skill_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Json(req): Json<CreateSkillRequest>,
 ) -> Result<(StatusCode, Json<SkillSpec>)> {
-    let skill = state.skills.create_skill(req)?;
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    let skill = state.skills.create_skill_with_context(&context, req)?;
     Ok((StatusCode::CREATED, Json(skill)))
 }
 
 async fn get_skill_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(skill_id): Path<String>,
 ) -> Result<Json<SkillSpec>> {
-    state.skills.get_skill(&skill_id).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    state
+        .skills
+        .get_skill_with_context(&context, &skill_id)
+        .map(Json)
 }
 
 async fn update_skill_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(skill_id): Path<String>,
     Json(req): Json<UpdateSkillRequest>,
 ) -> Result<Json<SkillSpec>> {
-    state.skills.update_skill(&skill_id, req).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    state
+        .skills
+        .update_skill_with_context(&context, &skill_id, req)
+        .map(Json)
 }
 
 async fn approve_skill_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(skill_id): Path<String>,
     Json(req): Json<RegistryActionRequest>,
 ) -> Result<Json<SkillSpec>> {
-    state.skills.approve_skill(&skill_id, req).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: req.actor.clone(),
+            ..RequestContextInput::default()
+        },
+    )?;
+    state
+        .skills
+        .approve_skill_with_context(&context, &skill_id, req)
+        .map(Json)
 }
 
 async fn disable_skill_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(skill_id): Path<String>,
     Json(req): Json<RegistryActionRequest>,
 ) -> Result<Json<SkillSpec>> {
-    state.skills.disable_skill(&skill_id, req).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: req.actor.clone(),
+            ..RequestContextInput::default()
+        },
+    )?;
+    state
+        .skills
+        .disable_skill_with_context(&context, &skill_id, req)
+        .map(Json)
 }
 
 async fn list_mcp_tools_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Query(query): Query<McpToolListQuery>,
 ) -> Result<Json<McpToolListResponse>> {
-    let page = state.mcp_tools.list_tools(&query)?;
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    let page = state.mcp_tools.list_tools_with_context(&context, &query)?;
     Ok(Json(McpToolListResponse {
         total: page.items.len(),
         tools: page.items,
@@ -761,48 +1115,116 @@ async fn list_mcp_tools_handler(
 
 async fn create_mcp_tool_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Json(req): Json<CreateMcpToolRequest>,
 ) -> Result<(StatusCode, Json<McpToolSpec>)> {
-    let tool = state.mcp_tools.create_tool(req)?;
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    let tool = state.mcp_tools.create_tool_with_context(&context, req)?;
     Ok((StatusCode::CREATED, Json(tool)))
 }
 
 async fn get_mcp_tool_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(tool_id): Path<String>,
 ) -> Result<Json<McpToolSpec>> {
-    state.mcp_tools.get_tool(&tool_id).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    state
+        .mcp_tools
+        .get_tool_with_context(&context, &tool_id)
+        .map(Json)
 }
 
 async fn update_mcp_tool_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(tool_id): Path<String>,
     Json(req): Json<UpdateMcpToolRequest>,
 ) -> Result<Json<McpToolSpec>> {
-    state.mcp_tools.update_tool(&tool_id, req).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    state
+        .mcp_tools
+        .update_tool_with_context(&context, &tool_id, req)
+        .map(Json)
 }
 
 async fn approve_mcp_tool_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(tool_id): Path<String>,
     Json(req): Json<RegistryActionRequest>,
 ) -> Result<Json<McpToolSpec>> {
-    state.mcp_tools.approve_tool(&tool_id, req).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: req.actor.clone(),
+            ..RequestContextInput::default()
+        },
+    )?;
+    state
+        .mcp_tools
+        .approve_tool_with_context(&context, &tool_id, req)
+        .map(Json)
 }
 
 async fn disable_mcp_tool_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(tool_id): Path<String>,
     Json(req): Json<RegistryActionRequest>,
 ) -> Result<Json<McpToolSpec>> {
-    state.mcp_tools.disable_tool(&tool_id, req).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: req.actor.clone(),
+            ..RequestContextInput::default()
+        },
+    )?;
+    state
+        .mcp_tools
+        .disable_tool_with_context(&context, &tool_id, req)
+        .map(Json)
 }
 
 async fn list_knowledge_sources_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Query(query): Query<KnowledgeSourceListQuery>,
 ) -> Result<Json<KnowledgeSourceListResponse>> {
-    let page = state.knowledge_sources.list_sources(&query)?;
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    let page = state
+        .knowledge_sources
+        .list_sources_with_context(&context, &query)?;
     Ok(Json(KnowledgeSourceListResponse {
         total: page.items.len(),
         sources: page.items,
@@ -812,60 +1234,122 @@ async fn list_knowledge_sources_handler(
 
 async fn create_knowledge_source_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Json(req): Json<CreateKnowledgeSourceRequest>,
 ) -> Result<(StatusCode, Json<KnowledgeSource>)> {
-    let source = state.knowledge_sources.create_source(req)?;
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    let source = state
+        .knowledge_sources
+        .create_source_with_context(&context, req)?;
     Ok((StatusCode::CREATED, Json(source)))
 }
 
 async fn get_knowledge_source_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(source_id): Path<String>,
 ) -> Result<Json<KnowledgeSource>> {
-    state.knowledge_sources.get_source(&source_id).map(Json)
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
+    state
+        .knowledge_sources
+        .get_source_with_context(&context, &source_id)
+        .map(Json)
 }
 
 async fn update_knowledge_source_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(source_id): Path<String>,
     Json(req): Json<UpdateKnowledgeSourceRequest>,
 ) -> Result<Json<KnowledgeSource>> {
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput::default(),
+    )?;
     state
         .knowledge_sources
-        .update_source(&source_id, req)
+        .update_source_with_context(&context, &source_id, req)
         .map(Json)
 }
 
 async fn ingest_knowledge_source_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(source_id): Path<String>,
     Json(req): Json<RegistryActionRequest>,
 ) -> Result<Json<KnowledgeIngestionJob>> {
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: req.actor.clone(),
+            ..RequestContextInput::default()
+        },
+    )?;
     state
         .knowledge_sources
-        .ingest_source(&source_id, req)
+        .ingest_source_with_context(&context, &source_id, req)
         .map(Json)
 }
 
 async fn approve_knowledge_source_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(source_id): Path<String>,
     Json(req): Json<RegistryActionRequest>,
 ) -> Result<Json<KnowledgeSource>> {
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: req.actor.clone(),
+            ..RequestContextInput::default()
+        },
+    )?;
     state
         .knowledge_sources
-        .approve_source(&source_id, req)
+        .approve_source_with_context(&context, &source_id, req)
         .map(Json)
 }
 
 async fn disable_knowledge_source_handler(
     State(state): State<AppState>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
     Path(source_id): Path<String>,
     Json(req): Json<RegistryActionRequest>,
 ) -> Result<Json<KnowledgeSource>> {
+    let context = request_context(
+        &state,
+        &headers,
+        raw_query.as_deref(),
+        RequestContextInput {
+            actor: req.actor.clone(),
+            ..RequestContextInput::default()
+        },
+    )?;
     state
         .knowledge_sources
-        .disable_source(&source_id, req)
+        .disable_source_with_context(&context, &source_id, req)
         .map(Json)
 }
 
diff --git a/04-backend/harness-core/src/knowledge_registry.rs b/04-backend/harness-core/src/knowledge_registry.rs
index 3e5282ea..a9041842 100644
--- a/04-backend/harness-core/src/knowledge_registry.rs
+++ b/04-backend/harness-core/src/knowledge_registry.rs
@@ -13,6 +13,7 @@ use serde::{Deserialize, Serialize};
 use crate::{
     error::{HarnessError, Result},
     module_pagination::{ListPage, PageInfo, paginate},
+    runtime_context::{PermissionGuard, RequestContext, RuntimePermission, assert_runtime_scope},
     skill_registry::RegistryActionRequest,
 };
 
@@ -124,6 +125,20 @@ pub struct KnowledgeSource {
     pub requirements_before_use: Vec<String>,
     /// Owner team or user id.
     pub owner: String,
+    /// Tenant id used for registry isolation.
+    pub tenant_id: String,
+    /// Project id used for registry isolation.
+    pub project_id: String,
+    /// Actor that created the registry record.
+    pub created_by: String,
+    /// Actor that last updated the registry record.
+    pub updated_by: String,
+    /// Monotonic in-memory registry record version.
+    pub record_version: u32,
+    /// Request id that created or last updated the record.
+    pub request_id: String,
+    /// Correlation id for the registry workflow.
+    pub correlation_id: String,
     /// Refresh policy description.
     pub refresh_policy: String,
     /// Permission policy description.
@@ -150,6 +165,16 @@ pub struct KnowledgeIngestionJob {
     pub id: uuid::Uuid,
     /// Source id.
     pub source_id: String,
+    /// Tenant id used for ingest isolation.
+    pub tenant_id: String,
+    /// Project id used for ingest isolation.
+    pub project_id: String,
+    /// Actor that requested ingest.
+    pub actor: String,
+    /// Request id that requested ingest.
+    pub request_id: String,
+    /// Correlation id for the ingest workflow.
+    pub correlation_id: String,
     /// Job status.
     pub status: String,
     /// Summary of mock ingest work.
@@ -286,6 +311,19 @@ impl KnowledgeSourceRegistryService {
     /// # Errors
     /// Returns [`HarnessError::InvalidInput`] for missing fields or duplicate ids.
     pub fn create_source(&self, req: CreateKnowledgeSourceRequest) -> Result<KnowledgeSource> {
+        self.create_source_with_context(&RequestContext::development_admin(), req)
+    }
+
+    /// Create a draft knowledge source under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, validation, or duplicate-id errors.
+    pub fn create_source_with_context(
+        &self,
+        context: &RequestContext,
+        req: CreateKnowledgeSourceRequest,
+    ) -> Result<KnowledgeSource> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryWrite)?;
         validate_required("name", &req.name)?;
         validate_required("source_url", &req.source_url)?;
         validate_required("license", &req.license)?;
@@ -315,6 +353,13 @@ impl KnowledgeSourceRegistryService {
             capabilities: req.capabilities.unwrap_or_default(),
             requirements_before_use: req.requirements_before_use.unwrap_or_default(),
             owner: req.owner,
+            tenant_id: context.tenant_id.clone(),
+            project_id: context.project_id.clone(),
+            created_by: context.actor.clone(),
+            updated_by: context.actor.clone(),
+            record_version: 1,
+            request_id: context.request_id.clone(),
+            correlation_id: context.correlation_id.clone(),
             refresh_policy: req.refresh_policy,
             permission_policy: req.permission_policy,
             audit_policy: req.audit_policy,
@@ -346,10 +391,26 @@ impl KnowledgeSourceRegistryService {
         &self,
         query: &KnowledgeSourceListQuery,
     ) -> Result<ListPage<KnowledgeSource>> {
+        self.list_sources_with_context(&RequestContext::development_admin(), query)
+    }
+
+    /// List knowledge sources visible to a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission or pagination errors.
+    pub fn list_sources_with_context(
+        &self,
+        context: &RequestContext,
+        query: &KnowledgeSourceListQuery,
+    ) -> Result<ListPage<KnowledgeSource>> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryRead)?;
         let mut items: Vec<KnowledgeSource> = self
             .sources
             .read()
             .values()
+            .filter(|source| {
+                source.tenant_id == context.tenant_id && source.project_id == context.project_id
+            })
             .filter(|source| query.kind.is_none_or(|kind| source.kind == kind))
             .filter(|source| query.status.is_none_or(|status| source.status == status))
             .filter(|source| {
@@ -369,11 +430,22 @@ impl KnowledgeSourceRegistryService {
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the source id is unknown.
     pub fn get_source(&self, source_id: &str) -> Result<KnowledgeSource> {
-        self.sources
-            .read()
-            .get(source_id)
-            .cloned()
-            .ok_or_else(|| HarnessError::NotFound(format!("source_id={source_id}")))
+        self.get_source_with_context(&RequestContext::development_admin(), source_id)
+    }
+
+    /// Get one knowledge source visible to a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing source, or scope errors.
+    pub fn get_source_with_context(
+        &self,
+        context: &RequestContext,
+        source_id: &str,
+    ) -> Result<KnowledgeSource> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryRead)?;
+        let source = self.get_source_unscoped(source_id)?;
+        assert_source_scope(context, &source)?;
+        Ok(source)
     }
 
     /// Patch one knowledge source.
@@ -385,7 +457,22 @@ impl KnowledgeSourceRegistryService {
         source_id: &str,
         req: UpdateKnowledgeSourceRequest,
     ) -> Result<KnowledgeSource> {
-        let mut source = self.get_source(source_id)?;
+        self.update_source_with_context(&RequestContext::development_admin(), source_id, req)
+    }
+
+    /// Patch one knowledge source under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing source, scope, or validation errors.
+    pub fn update_source_with_context(
+        &self,
+        context: &RequestContext,
+        source_id: &str,
+        req: UpdateKnowledgeSourceRequest,
+    ) -> Result<KnowledgeSource> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryWrite)?;
+        let mut source = self.get_source_unscoped(source_id)?;
+        assert_source_scope(context, &source)?;
         if let Some(name) = req.name {
             validate_required("name", &name)?;
             source.name = name;
@@ -450,6 +537,10 @@ impl KnowledgeSourceRegistryService {
         } else {
             source.status = KnowledgeSourceStatus::Draft;
         }
+        source.updated_by.clone_from(&context.actor);
+        source.record_version = source.record_version.saturating_add(1);
+        source.request_id.clone_from(&context.request_id);
+        source.correlation_id.clone_from(&context.correlation_id);
         source.updated_at = Utc::now();
         self.sources
             .write()
@@ -464,9 +555,24 @@ impl KnowledgeSourceRegistryService {
     pub fn ingest_source(
         &self,
         source_id: &str,
+        req: RegistryActionRequest,
+    ) -> Result<KnowledgeIngestionJob> {
+        self.ingest_source_with_context(&RequestContext::development_admin(), source_id, req)
+    }
+
+    /// Mock ingest one knowledge source under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing source, scope, or invalid state errors.
+    pub fn ingest_source_with_context(
+        &self,
+        context: &RequestContext,
+        source_id: &str,
         _req: RegistryActionRequest,
     ) -> Result<KnowledgeIngestionJob> {
-        let mut source = self.get_source(source_id)?;
+        PermissionGuard::ensure(context, RuntimePermission::KnowledgeIngest)?;
+        let mut source = self.get_source_unscoped(source_id)?;
+        assert_source_scope(context, &source)?;
         match source.status {
             KnowledgeSourceStatus::Disabled => {
                 return Err(HarnessError::InvalidInput(format!(
@@ -482,11 +588,20 @@ impl KnowledgeSourceRegistryService {
             }
         }
         source.updated_at = Utc::now();
+        source.updated_by.clone_from(&context.actor);
+        source.record_version = source.record_version.saturating_add(1);
+        source.request_id.clone_from(&context.request_id);
+        source.correlation_id.clone_from(&context.correlation_id);
         self.sources.write().insert(source_id.to_owned(), source);
         let now = Utc::now();
         let job = KnowledgeIngestionJob {
             id: uuid::Uuid::new_v4(),
             source_id: source_id.to_owned(),
+            tenant_id: context.tenant_id.clone(),
+            project_id: context.project_id.clone(),
+            actor: context.actor.clone(),
+            request_id: context.request_id.clone(),
+            correlation_id: context.correlation_id.clone(),
             status: "completed".to_owned(),
             summary: "mock ingest recorded registry metadata only; no external crawl executed"
                 .to_owned(),
@@ -504,9 +619,24 @@ impl KnowledgeSourceRegistryService {
     pub fn approve_source(
         &self,
         source_id: &str,
+        req: RegistryActionRequest,
+    ) -> Result<KnowledgeSource> {
+        self.approve_source_with_context(&RequestContext::development_admin(), source_id, req)
+    }
+
+    /// Approve one knowledge source under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing source, or scope errors.
+    pub fn approve_source_with_context(
+        &self,
+        context: &RequestContext,
+        source_id: &str,
         _req: RegistryActionRequest,
     ) -> Result<KnowledgeSource> {
-        let mut source = self.get_source(source_id)?;
+        PermissionGuard::ensure(context, RuntimePermission::RegistryApprove)?;
+        let mut source = self.get_source_unscoped(source_id)?;
+        assert_source_scope(context, &source)?;
         if is_candidate_only(&source.license, source.vendor_id.as_deref()) {
             source.status = KnowledgeSourceStatus::CandidateOnly;
             source.production_enabled = false;
@@ -514,6 +644,10 @@ impl KnowledgeSourceRegistryService {
         } else {
             source.status = KnowledgeSourceStatus::Approved;
         }
+        source.updated_by.clone_from(&context.actor);
+        source.record_version = source.record_version.saturating_add(1);
+        source.request_id.clone_from(&context.request_id);
+        source.correlation_id.clone_from(&context.correlation_id);
         source.updated_at = Utc::now();
         self.sources
             .write()
@@ -528,12 +662,31 @@ impl KnowledgeSourceRegistryService {
     pub fn disable_source(
         &self,
         source_id: &str,
+        req: RegistryActionRequest,
+    ) -> Result<KnowledgeSource> {
+        self.disable_source_with_context(&RequestContext::development_admin(), source_id, req)
+    }
+
+    /// Disable one knowledge source under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing source, or scope errors.
+    pub fn disable_source_with_context(
+        &self,
+        context: &RequestContext,
+        source_id: &str,
         _req: RegistryActionRequest,
     ) -> Result<KnowledgeSource> {
-        let mut source = self.get_source(source_id)?;
+        PermissionGuard::ensure(context, RuntimePermission::RegistryWrite)?;
+        let mut source = self.get_source_unscoped(source_id)?;
+        assert_source_scope(context, &source)?;
         source.status = KnowledgeSourceStatus::Disabled;
         source.production_enabled = false;
         "disabled".clone_into(&mut source.default_route);
+        source.updated_by.clone_from(&context.actor);
+        source.record_version = source.record_version.saturating_add(1);
+        source.request_id.clone_from(&context.request_id);
+        source.correlation_id.clone_from(&context.correlation_id);
         source.updated_at = Utc::now();
         self.sources
             .write()
@@ -542,6 +695,20 @@ impl KnowledgeSourceRegistryService {
     }
 }
 
+impl KnowledgeSourceRegistryService {
+    fn get_source_unscoped(&self, source_id: &str) -> Result<KnowledgeSource> {
+        self.sources
+            .read()
+            .get(source_id)
+            .cloned()
+            .ok_or_else(|| HarnessError::NotFound(format!("source_id={source_id}")))
+    }
+}
+
+fn assert_source_scope(context: &RequestContext, source: &KnowledgeSource) -> Result<()> {
+    assert_runtime_scope(context, &source.tenant_id, &source.project_id)
+}
+
 fn validate_required(field: &str, value: &str) -> Result<()> {
     if value.trim().is_empty() {
         return Err(HarnessError::InvalidInput(format!("{field} is required")));
@@ -577,6 +744,7 @@ fn validate_github_trending_policy(source_url: &str, refresh_policy: &str) -> Re
 
 #[cfg(test)]
 mod tests {
+    use crate::runtime_context::{RequestContext, RequestContextInput, RuntimeProfile};
     use crate::skill_registry::RegistryActionRequest;
 
     use super::{
@@ -617,6 +785,21 @@ mod tests {
         }
     }
 
+    fn context(actor: &str, roles: &[&str]) -> RequestContext {
+        RequestContext::from_input(
+            RequestContextInput {
+                tenant_id: Some("tenant-a".to_owned()),
+                project_id: Some("project-a".to_owned()),
+                actor: Some(actor.to_owned()),
+                roles: Some(roles.iter().map(|role| (*role).to_owned()).collect()),
+                request_id: Some(format!("req-{actor}")),
+                correlation_id: Some(format!("corr-{actor}")),
+            },
+            RuntimeProfile::Production,
+        )
+        .expect("context should parse")
+    }
+
     #[test]
     fn knowledge_source_registry_create_ingest_approve_disable() {
         let registry = KnowledgeSourceRegistryService::new();
@@ -673,6 +856,35 @@ mod tests {
         );
     }
 
+    #[test]
+    fn knowledge_ingest_requires_knowledge_ingest_permission() {
+        let registry = KnowledgeSourceRegistryService::new();
+        let engineer = context("engineer", &["engineer"]);
+        let admin = context("admin", &["admin"]);
+        registry
+            .create_source_with_context(&engineer, create_request("ingest-permission"))
+            .expect("engineer can create source");
+
+        let err = registry
+            .ingest_source_with_context(
+                &engineer,
+                "ingest-permission",
+                RegistryActionRequest::default(),
+            )
+            .expect_err("engineer cannot ingest knowledge");
+        assert_eq!(err.http_status(), 403);
+
+        let job = registry
+            .ingest_source_with_context(
+                &admin,
+                "ingest-permission",
+                RegistryActionRequest::default(),
+            )
+            .expect("admin can ingest knowledge");
+        assert_eq!(job.status, "completed");
+        assert_eq!(job.tenant_id, "tenant-a");
+    }
+
     #[test]
     fn proprietary_vendor_source_remains_candidate_only() {
         let registry = KnowledgeSourceRegistryService::new();
diff --git a/04-backend/harness-core/src/lib.rs b/04-backend/harness-core/src/lib.rs
index b075befd..711d9f6e 100644
--- a/04-backend/harness-core/src/lib.rs
+++ b/04-backend/harness-core/src/lib.rs
@@ -38,6 +38,7 @@ pub mod permissions;
 pub mod rag;
 pub mod rollback_guard;
 pub mod runtime_capabilities;
+pub mod runtime_context;
 pub mod skill_registry;
 pub mod sla;
 pub mod storage_router;
diff --git a/04-backend/harness-core/src/mcp_tool_registry.rs b/04-backend/harness-core/src/mcp_tool_registry.rs
index 489ca1e0..10c1b714 100644
--- a/04-backend/harness-core/src/mcp_tool_registry.rs
+++ b/04-backend/harness-core/src/mcp_tool_registry.rs
@@ -13,6 +13,7 @@ use serde::{Deserialize, Serialize};
 use crate::{
     error::{HarnessError, Result},
     module_pagination::{ListPage, PageInfo, paginate},
+    runtime_context::{PermissionGuard, RequestContext, RuntimePermission, assert_runtime_scope},
     skill_registry::RegistryActionRequest,
 };
 
@@ -75,6 +76,20 @@ pub struct McpToolSpec {
     pub name: String,
     /// Owner team or user id.
     pub owner: String,
+    /// Tenant id used for registry isolation.
+    pub tenant_id: String,
+    /// Project id used for registry isolation.
+    pub project_id: String,
+    /// Actor that created the registry record.
+    pub created_by: String,
+    /// Actor that last updated the registry record.
+    pub updated_by: String,
+    /// Monotonic in-memory registry record version.
+    pub record_version: u32,
+    /// Request id that created or last updated the record.
+    pub request_id: String,
+    /// Correlation id for the registry workflow.
+    pub correlation_id: String,
     /// Tool version.
     pub version: String,
     /// Declared capability.
@@ -196,6 +211,19 @@ impl McpToolRegistryService {
     /// # Errors
     /// Returns [`HarnessError::InvalidInput`] for missing fields or duplicate ids.
     pub fn create_tool(&self, req: CreateMcpToolRequest) -> Result<McpToolSpec> {
+        self.create_tool_with_context(&RequestContext::development_admin(), req)
+    }
+
+    /// Create a draft MCP tool under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, validation, or duplicate-id errors.
+    pub fn create_tool_with_context(
+        &self,
+        context: &RequestContext,
+        req: CreateMcpToolRequest,
+    ) -> Result<McpToolSpec> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryWrite)?;
         validate_required("name", &req.name)?;
         validate_required("owner", &req.owner)?;
         validate_required("input_schema_ref", &req.input_schema_ref)?;
@@ -211,6 +239,13 @@ impl McpToolRegistryService {
             id: id.clone(),
             name: req.name,
             owner: req.owner,
+            tenant_id: context.tenant_id.clone(),
+            project_id: context.project_id.clone(),
+            created_by: context.actor.clone(),
+            updated_by: context.actor.clone(),
+            record_version: 1,
+            request_id: context.request_id.clone(),
+            correlation_id: context.correlation_id.clone(),
             version: req.version,
             capability: req.capability,
             permission_scope: req.permission_scope,
@@ -238,10 +273,26 @@ impl McpToolRegistryService {
     /// # Errors
     /// Returns [`HarnessError::InvalidInput`] when pagination cursor is invalid.
     pub fn list_tools(&self, query: &McpToolListQuery) -> Result<ListPage<McpToolSpec>> {
+        self.list_tools_with_context(&RequestContext::development_admin(), query)
+    }
+
+    /// List MCP tools visible to a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission or pagination errors.
+    pub fn list_tools_with_context(
+        &self,
+        context: &RequestContext,
+        query: &McpToolListQuery,
+    ) -> Result<ListPage<McpToolSpec>> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryRead)?;
         let mut items: Vec<McpToolSpec> = self
             .tools
             .read()
             .values()
+            .filter(|tool| {
+                tool.tenant_id == context.tenant_id && tool.project_id == context.project_id
+            })
             .filter(|tool| query.status.is_none_or(|status| tool.status == status))
             .filter(|tool| {
                 query
@@ -260,11 +311,22 @@ impl McpToolRegistryService {
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the tool id is unknown.
     pub fn get_tool(&self, tool_id: &str) -> Result<McpToolSpec> {
-        self.tools
-            .read()
-            .get(tool_id)
-            .cloned()
-            .ok_or_else(|| HarnessError::NotFound(format!("tool_id={tool_id}")))
+        self.get_tool_with_context(&RequestContext::development_admin(), tool_id)
+    }
+
+    /// Get one MCP tool visible to a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing record, or scope errors.
+    pub fn get_tool_with_context(
+        &self,
+        context: &RequestContext,
+        tool_id: &str,
+    ) -> Result<McpToolSpec> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryRead)?;
+        let tool = self.get_tool_unscoped(tool_id)?;
+        assert_tool_scope(context, &tool)?;
+        Ok(tool)
     }
 
     /// Patch one MCP tool.
@@ -273,10 +335,25 @@ impl McpToolRegistryService {
     /// Returns [`HarnessError::NotFound`] when the tool id is unknown and
     /// [`HarnessError::InvalidInput`] for invalid limits.
     pub fn update_tool(&self, tool_id: &str, req: UpdateMcpToolRequest) -> Result<McpToolSpec> {
+        self.update_tool_with_context(&RequestContext::development_admin(), tool_id, req)
+    }
+
+    /// Patch one MCP tool under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing record, scope, or validation errors.
+    pub fn update_tool_with_context(
+        &self,
+        context: &RequestContext,
+        tool_id: &str,
+        req: UpdateMcpToolRequest,
+    ) -> Result<McpToolSpec> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryWrite)?;
         if let (Some(timeout_ms), Some(rate_limit)) = (req.timeout_ms, req.rate_limit_per_minute) {
             validate_tool_limits(timeout_ms, rate_limit)?;
         }
-        let mut tool = self.get_tool(tool_id)?;
+        let mut tool = self.get_tool_unscoped(tool_id)?;
+        assert_tool_scope(context, &tool)?;
         if let Some(name) = req.name {
             validate_required("name", &name)?;
             tool.name = name;
@@ -315,6 +392,10 @@ impl McpToolRegistryService {
             tool.audit_policy = audit_policy;
         }
         tool.status = McpToolStatus::Draft;
+        tool.updated_by.clone_from(&context.actor);
+        tool.record_version = tool.record_version.saturating_add(1);
+        tool.request_id.clone_from(&context.request_id);
+        tool.correlation_id.clone_from(&context.correlation_id);
         tool.updated_at = Utc::now();
         self.tools.write().insert(tool_id.to_owned(), tool.clone());
         Ok(tool)
@@ -324,8 +405,23 @@ impl McpToolRegistryService {
     ///
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the tool id is unknown.
-    pub fn approve_tool(&self, tool_id: &str, _req: RegistryActionRequest) -> Result<McpToolSpec> {
-        let mut tool = self.get_tool(tool_id)?;
+    pub fn approve_tool(&self, tool_id: &str, req: RegistryActionRequest) -> Result<McpToolSpec> {
+        self.approve_tool_with_context(&RequestContext::development_admin(), tool_id, req)
+    }
+
+    /// Approve one MCP tool under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing record, scope, or validation errors.
+    pub fn approve_tool_with_context(
+        &self,
+        context: &RequestContext,
+        tool_id: &str,
+        _req: RegistryActionRequest,
+    ) -> Result<McpToolSpec> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryApprove)?;
+        let mut tool = self.get_tool_unscoped(tool_id)?;
+        assert_tool_scope(context, &tool)?;
         validate_permission_scope(&tool.permission_scope)?;
         validate_tool_limits(tool.timeout_ms, tool.rate_limit_per_minute)?;
         if !tool.audit_policy.audit_required {
@@ -334,6 +430,10 @@ impl McpToolRegistryService {
             ));
         }
         tool.status = McpToolStatus::Approved;
+        tool.updated_by.clone_from(&context.actor);
+        tool.record_version = tool.record_version.saturating_add(1);
+        tool.request_id.clone_from(&context.request_id);
+        tool.correlation_id.clone_from(&context.correlation_id);
         tool.updated_at = Utc::now();
         self.tools.write().insert(tool_id.to_owned(), tool.clone());
         Ok(tool)
@@ -343,15 +443,48 @@ impl McpToolRegistryService {
     ///
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the tool id is unknown.
-    pub fn disable_tool(&self, tool_id: &str, _req: RegistryActionRequest) -> Result<McpToolSpec> {
-        let mut tool = self.get_tool(tool_id)?;
+    pub fn disable_tool(&self, tool_id: &str, req: RegistryActionRequest) -> Result<McpToolSpec> {
+        self.disable_tool_with_context(&RequestContext::development_admin(), tool_id, req)
+    }
+
+    /// Disable one MCP tool under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing record, or scope errors.
+    pub fn disable_tool_with_context(
+        &self,
+        context: &RequestContext,
+        tool_id: &str,
+        _req: RegistryActionRequest,
+    ) -> Result<McpToolSpec> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryWrite)?;
+        let mut tool = self.get_tool_unscoped(tool_id)?;
+        assert_tool_scope(context, &tool)?;
         tool.status = McpToolStatus::Disabled;
+        tool.updated_by.clone_from(&context.actor);
+        tool.record_version = tool.record_version.saturating_add(1);
+        tool.request_id.clone_from(&context.request_id);
+        tool.correlation_id.clone_from(&context.correlation_id);
         tool.updated_at = Utc::now();
         self.tools.write().insert(tool_id.to_owned(), tool.clone());
         Ok(tool)
     }
 }
 
+impl McpToolRegistryService {
+    fn get_tool_unscoped(&self, tool_id: &str) -> Result<McpToolSpec> {
+        self.tools
+            .read()
+            .get(tool_id)
+            .cloned()
+            .ok_or_else(|| HarnessError::NotFound(format!("tool_id={tool_id}")))
+    }
+}
+
+fn assert_tool_scope(context: &RequestContext, tool: &McpToolSpec) -> Result<()> {
+    assert_runtime_scope(context, &tool.tenant_id, &tool.project_id)
+}
+
 fn validate_required(field: &str, value: &str) -> Result<()> {
     if value.trim().is_empty() {
         return Err(HarnessError::InvalidInput(format!("{field} is required")));
diff --git a/04-backend/harness-core/src/module_generation.rs b/04-backend/harness-core/src/module_generation.rs
index b677a0a0..16dbbd75 100644
--- a/04-backend/harness-core/src/module_generation.rs
+++ b/04-backend/harness-core/src/module_generation.rs
@@ -22,6 +22,7 @@ use crate::{
     },
     module_pagination::{ListPage, PageInfo, paginate},
     module_registry::normalize_module_id,
+    runtime_context::{PermissionGuard, RequestContext, RuntimePermission, assert_runtime_scope},
     storage_router::{
         ArtifactMetadata, ArtifactRef, ArtifactRole, ArtifactStatus, ArtifactStorageBinding,
         ArtifactVersion, ElementIdNamespace, GeometryFormat, InMemoryObjectStore, ObjectPutRequest,
@@ -591,6 +592,10 @@ pub struct GenerationJob {
     pub lifecycle_transaction_id: Option<Uuid>,
     /// Actor that created the job.
     pub actor: String,
+    /// Current request context for tenant/project isolation and audit.
+    pub context: RequestContext,
+    /// Monotonic in-memory record version.
+    pub version: u32,
     /// Creation timestamp.
     pub created_at: DateTime<Utc>,
     /// Last update timestamp.
@@ -613,7 +618,7 @@ pub struct GenerationJobQuery {
 }
 
 /// Generic action request used by plan, run, approve, and reject.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GenerationActionRequest {
     /// Actor performing the action.
@@ -711,7 +716,22 @@ impl ModuleGenerationService {
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the module id cannot be normalized
     /// and [`HarnessError::InvalidInput`] when the prompt is empty.
-    pub fn create_job(&self, mut input: GenerationInput) -> Result<GenerationJob> {
+    pub fn create_job(&self, input: GenerationInput) -> Result<GenerationJob> {
+        self.create_job_with_context(&RequestContext::development_admin(), input)
+    }
+
+    /// Create a queued generation job under a runtime context.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::SandboxDenied`] when permission is denied,
+    /// [`HarnessError::NotFound`] when the module id cannot be normalized, and
+    /// [`HarnessError::InvalidInput`] when the prompt is empty.
+    pub fn create_job_with_context(
+        &self,
+        context: &RequestContext,
+        mut input: GenerationInput,
+    ) -> Result<GenerationJob> {
+        PermissionGuard::ensure(context, RuntimePermission::GenerationCreate)?;
         let module_id = normalize_module_id(&input.module_id)
             .ok_or_else(|| HarnessError::NotFound(format!("module_id={}", input.module_id)))?;
         if input.prompt.trim().is_empty() {
@@ -719,12 +739,15 @@ impl ModuleGenerationService {
         }
 
         module_id.as_str().clone_into(&mut input.module_id);
-        let actor = input
-            .actor
-            .clone()
-            .unwrap_or_else(|| DEFAULT_ACTOR.to_owned());
+        let actor = input.actor.clone().unwrap_or_else(|| context.actor.clone());
+        if input.actor.is_none() {
+            input.actor = Some(actor.clone());
+        }
         let now = Utc::now();
-        let artifacts = normalize_input_artifacts(input.input_artifacts.take());
+        let mut artifacts = normalize_input_artifacts(input.input_artifacts.take());
+        for artifact in &mut artifacts {
+            stamp_artifact_context(artifact, context);
+        }
         input.input_artifacts = Some(artifacts.clone());
         let lifecycle_transaction =
             self.lifecycle
@@ -756,6 +779,8 @@ impl ModuleGenerationService {
             artifacts,
             lifecycle_transaction_id: Some(lifecycle_transaction.id),
             actor,
+            context: context.clone(),
+            version: 1,
             created_at: now,
             updated_at: now,
         };
@@ -765,7 +790,7 @@ impl ModuleGenerationService {
             AuditEventKind::GenerationJobCreated,
             job.actor.clone(),
             "generation job created",
-            json!({ "mode": job.mode }),
+            json!({ "mode": job.mode, "context": context.audit_json() }),
         );
         Ok(job)
     }
@@ -775,6 +800,21 @@ impl ModuleGenerationService {
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the optional module id cannot be normalized.
     pub fn list_jobs(&self, query: &GenerationJobQuery) -> Result<ListPage<GenerationJob>> {
+        self.list_jobs_with_context(&RequestContext::development_admin(), query)
+    }
+
+    /// List generation jobs visible to a runtime context.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::SandboxDenied`] when permission is denied,
+    /// [`HarnessError::NotFound`] when the optional module id cannot be normalized,
+    /// or [`HarnessError::InvalidInput`] for invalid pagination cursors.
+    pub fn list_jobs_with_context(
+        &self,
+        context: &RequestContext,
+        query: &GenerationJobQuery,
+    ) -> Result<ListPage<GenerationJob>> {
+        PermissionGuard::ensure(context, RuntimePermission::ArtifactRead)?;
         let normalized = query
             .module_id
             .as_deref()
@@ -787,6 +827,10 @@ impl ModuleGenerationService {
             .jobs
             .read()
             .values()
+            .filter(|job| {
+                job.context.tenant_id == context.tenant_id
+                    && job.context.project_id == context.project_id
+            })
             .filter(|job| {
                 normalized
                     .as_ref()
@@ -809,11 +853,29 @@ impl ModuleGenerationService {
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the job id is unknown.
     pub fn get_job(&self, job_id: Uuid) -> Result<GenerationJob> {
-        self.jobs
+        self.get_job_with_context(&RequestContext::development_admin(), job_id)
+    }
+
+    /// Get one generation job visible to a runtime context.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::SandboxDenied`] when permission is denied,
+    /// [`HarnessError::NotFound`] when the job id is unknown, or
+    /// [`HarnessError::TenantIsolation`] when the scope differs.
+    pub fn get_job_with_context(
+        &self,
+        context: &RequestContext,
+        job_id: Uuid,
+    ) -> Result<GenerationJob> {
+        PermissionGuard::ensure(context, RuntimePermission::ArtifactRead)?;
+        let job = self
+            .jobs
             .read()
             .get(&job_id)
             .cloned()
-            .ok_or_else(|| HarnessError::NotFound(format!("generation_job_id={job_id}")))
+            .ok_or_else(|| HarnessError::NotFound(format!("generation_job_id={job_id}")))?;
+        assert_job_scope(context, &job)?;
+        Ok(job)
     }
 
     /// Run the planner stage.
@@ -822,8 +884,25 @@ impl ModuleGenerationService {
     /// Returns [`HarnessError::NotFound`] when the job id is unknown and
     /// [`HarnessError::InvalidInput`] when the job is not queued.
     pub fn plan_job(&self, job_id: Uuid, req: GenerationActionRequest) -> Result<GenerationJob> {
+        self.plan_job_with_context(&RequestContext::development_admin(), job_id, req)
+    }
+
+    /// Run the planner stage under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, scope, missing job, or invalid status errors.
+    pub fn plan_job_with_context(
+        &self,
+        context: &RequestContext,
+        job_id: Uuid,
+        mut req: GenerationActionRequest,
+    ) -> Result<GenerationJob> {
+        PermissionGuard::ensure(context, RuntimePermission::GenerationRun)?;
+        if req.actor.is_none() {
+            req.actor = Some(context.actor.clone());
+        }
         let lifecycle = self.lifecycle.clone();
-        self.mutate_job(job_id, |job| {
+        self.mutate_job(context, job_id, |job| {
             ensure_status(job, &[GenerationJobStatus::Queued])?;
             transition_lifecycle(
                 &lifecycle,
@@ -858,13 +937,13 @@ impl ModuleGenerationService {
                     AuditEventKind::GenerationJobPlanned,
                     actor.clone(),
                     "generation job planned",
-                    json!({ "stage": GenerationStage::Planner }),
+                    json!({ "stage": GenerationStage::Planner, "context": context.audit_json() }),
                 ),
                 AuditSpec::new(
                     AuditEventKind::GenerationStageCompleted,
                     actor,
                     "generation planner stage completed",
-                    json!({ "stage": GenerationStage::Planner }),
+                    json!({ "stage": GenerationStage::Planner, "context": context.audit_json() }),
                 ),
             ])
         })
@@ -876,9 +955,26 @@ impl ModuleGenerationService {
     /// Returns [`HarnessError::NotFound`] when the job id is unknown and
     /// [`HarnessError::InvalidInput`] when the job was not planned.
     pub fn run_job(&self, job_id: Uuid, req: GenerationActionRequest) -> Result<GenerationJob> {
+        self.run_job_with_context(&RequestContext::development_admin(), job_id, req)
+    }
+
+    /// Run the mock generator pipeline under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, scope, missing job, or invalid status errors.
+    pub fn run_job_with_context(
+        &self,
+        context: &RequestContext,
+        job_id: Uuid,
+        mut req: GenerationActionRequest,
+    ) -> Result<GenerationJob> {
+        PermissionGuard::ensure(context, RuntimePermission::GenerationRun)?;
+        if req.actor.is_none() {
+            req.actor = Some(context.actor.clone());
+        }
         let lifecycle = self.lifecycle.clone();
         let object_store = self.object_store.clone();
-        self.mutate_job(job_id, |job| {
+        self.mutate_job(context, job_id, |job| {
             ensure_status(job, &[GenerationJobStatus::Planned])?;
             transition_lifecycle_stages(
                 &lifecycle,
@@ -903,8 +999,25 @@ impl ModuleGenerationService {
     /// Returns [`HarnessError::NotFound`] when the job id is unknown and
     /// [`HarnessError::InvalidInput`] when review is not allowed.
     pub fn review_job(&self, job_id: Uuid, req: GenerationReviewRequest) -> Result<GenerationJob> {
+        self.review_job_with_context(&RequestContext::development_admin(), job_id, req)
+    }
+
+    /// Append an active-review record under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, scope, missing job, or invalid status errors.
+    pub fn review_job_with_context(
+        &self,
+        context: &RequestContext,
+        job_id: Uuid,
+        mut req: GenerationReviewRequest,
+    ) -> Result<GenerationJob> {
+        PermissionGuard::ensure(context, RuntimePermission::GenerationReview)?;
+        if req.reviewer.trim().is_empty() {
+            req.reviewer.clone_from(&context.actor);
+        }
         let lifecycle = self.lifecycle.clone();
-        self.mutate_job(job_id, |job| {
+        self.mutate_job(context, job_id, |job| {
             ensure_status(job, &[GenerationJobStatus::PendingReview])?;
             if req.decision == GenerationReviewDecision::Rejected {
                 reject_lifecycle(
@@ -942,14 +1055,14 @@ impl ModuleGenerationService {
                 AuditEventKind::GenerationJobReviewed,
                 req.reviewer.clone(),
                 "generation job active review completed",
-                json!({ "decision": req.decision, "comment": req.comment }),
+                json!({ "decision": req.decision, "comment": req.comment, "context": context.audit_json() }),
             )];
             if req.decision == GenerationReviewDecision::Rejected {
                 audits.push(AuditSpec::new(
                     AuditEventKind::GenerationJobRejected,
                     req.reviewer,
                     "generation job rejected during active review",
-                    json!({ "status": job.status }),
+                    json!({ "status": job.status, "context": context.audit_json() }),
                 ));
             }
             Ok(audits)
@@ -962,8 +1075,25 @@ impl ModuleGenerationService {
     /// Returns [`HarnessError::NotFound`] when the job id is unknown and
     /// [`HarnessError::InvalidInput`] when approval is not allowed.
     pub fn approve_job(&self, job_id: Uuid, req: GenerationActionRequest) -> Result<GenerationJob> {
+        self.approve_job_with_context(&RequestContext::development_admin(), job_id, req)
+    }
+
+    /// Approve a reviewed generation job under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, scope, missing job, or invalid status errors.
+    pub fn approve_job_with_context(
+        &self,
+        context: &RequestContext,
+        job_id: Uuid,
+        mut req: GenerationActionRequest,
+    ) -> Result<GenerationJob> {
+        PermissionGuard::ensure(context, RuntimePermission::GenerationApprove)?;
+        if req.actor.is_none() {
+            req.actor = Some(context.actor.clone());
+        }
         let lifecycle = self.lifecycle.clone();
-        self.mutate_job(job_id, |job| {
+        self.mutate_job(context, job_id, |job| {
             ensure_status(job, &[GenerationJobStatus::PendingApproval])?;
             approve_lifecycle(
                 &lifecycle,
@@ -988,13 +1118,13 @@ impl ModuleGenerationService {
                     AuditEventKind::GenerationStageCompleted,
                     actor.clone(),
                     "generation approver stage completed",
-                    json!({ "stage": GenerationStage::Approver, "decision": "approved" }),
+                    json!({ "stage": GenerationStage::Approver, "decision": "approved", "context": context.audit_json() }),
                 ),
                 AuditSpec::new(
                     AuditEventKind::GenerationJobApproved,
                     actor,
                     "generation job approved",
-                    json!({ "status": job.status }),
+                    json!({ "status": job.status, "context": context.audit_json() }),
                 ),
             ])
         })
@@ -1005,8 +1135,25 @@ impl ModuleGenerationService {
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the job id is unknown.
     pub fn reject_job(&self, job_id: Uuid, req: GenerationActionRequest) -> Result<GenerationJob> {
+        self.reject_job_with_context(&RequestContext::development_admin(), job_id, req)
+    }
+
+    /// Reject a generation job under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, scope, missing job, or invalid status errors.
+    pub fn reject_job_with_context(
+        &self,
+        context: &RequestContext,
+        job_id: Uuid,
+        mut req: GenerationActionRequest,
+    ) -> Result<GenerationJob> {
+        PermissionGuard::ensure(context, RuntimePermission::GenerationApprove)?;
+        if req.actor.is_none() {
+            req.actor = Some(context.actor.clone());
+        }
         let lifecycle = self.lifecycle.clone();
-        self.mutate_job(job_id, |job| {
+        self.mutate_job(context, job_id, |job| {
             if matches!(
                 job.status,
                 GenerationJobStatus::Approved
@@ -1046,13 +1193,13 @@ impl ModuleGenerationService {
                     AuditEventKind::GenerationStageCompleted,
                     actor.clone(),
                     "generation approver stage completed",
-                    json!({ "stage": GenerationStage::Approver, "decision": "rejected" }),
+                    json!({ "stage": GenerationStage::Approver, "decision": "rejected", "context": context.audit_json() }),
                 ),
                 AuditSpec::new(
                     AuditEventKind::GenerationJobRejected,
                     actor,
                     "generation job rejected",
-                    json!({ "status": job.status }),
+                    json!({ "status": job.status, "context": context.audit_json() }),
                 ),
             ])
         })
@@ -1063,7 +1210,20 @@ impl ModuleGenerationService {
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the job id is unknown.
     pub fn list_artifacts(&self, job_id: Uuid) -> Result<GenerationArtifactsResponse> {
-        let job = self.get_job(job_id)?;
+        self.list_artifacts_with_context(&RequestContext::development_admin(), job_id)
+    }
+
+    /// List artifacts attached to one generation job under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, scope, or missing job errors.
+    pub fn list_artifacts_with_context(
+        &self,
+        context: &RequestContext,
+        job_id: Uuid,
+    ) -> Result<GenerationArtifactsResponse> {
+        PermissionGuard::ensure(context, RuntimePermission::ArtifactRead)?;
+        let job = self.get_job_with_context(context, job_id)?;
         Ok(GenerationArtifactsResponse {
             job_id,
             artifacts: job.artifacts,
@@ -1076,6 +1236,19 @@ impl ModuleGenerationService {
     /// Returns [`HarnessError::NotFound`] when the optional module id cannot be normalized
     /// and [`HarnessError::InvalidInput`] for invalid pagination cursors.
     pub fn list_indexed_artifacts(&self, query: &ArtifactListQuery) -> Result<ListPage<Artifact>> {
+        self.list_indexed_artifacts_with_context(&RequestContext::development_admin(), query)
+    }
+
+    /// List artifacts across all generation jobs visible to a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, module normalization, or pagination errors.
+    pub fn list_indexed_artifacts_with_context(
+        &self,
+        context: &RequestContext,
+        query: &ArtifactListQuery,
+    ) -> Result<ListPage<Artifact>> {
+        PermissionGuard::ensure(context, RuntimePermission::ArtifactRead)?;
         let normalized = query
             .module_id
             .as_deref()
@@ -1088,6 +1261,10 @@ impl ModuleGenerationService {
             .jobs
             .read()
             .values()
+            .filter(|job| {
+                job.context.tenant_id == context.tenant_id
+                    && job.context.project_id == context.project_id
+            })
             .flat_map(|job| job.artifacts.iter())
             .filter(|artifact| {
                 normalized
@@ -1117,13 +1294,33 @@ impl ModuleGenerationService {
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the artifact id is unknown.
     pub fn get_artifact(&self, artifact_id: Uuid) -> Result<Artifact> {
-        self.jobs
+        self.get_artifact_with_context(&RequestContext::development_admin(), artifact_id)
+    }
+
+    /// Get one artifact visible to a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing artifact, or scope errors.
+    pub fn get_artifact_with_context(
+        &self,
+        context: &RequestContext,
+        artifact_id: Uuid,
+    ) -> Result<Artifact> {
+        PermissionGuard::ensure(context, RuntimePermission::ArtifactRead)?;
+        let artifact = self
+            .jobs
             .read()
             .values()
             .flat_map(|job| job.artifacts.iter())
             .find(|artifact| artifact.id == artifact_id)
             .cloned()
-            .ok_or_else(|| HarnessError::NotFound(format!("artifact_id={artifact_id}")))
+            .ok_or_else(|| HarnessError::NotFound(format!("artifact_id={artifact_id}")))?;
+        assert_runtime_scope(
+            context,
+            &artifact.artifact_metadata.tenant_id,
+            &artifact.artifact_metadata.project_id,
+        )?;
+        Ok(artifact)
     }
 
     /// Get one artifact's version history.
@@ -1131,7 +1328,21 @@ impl ModuleGenerationService {
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the artifact id is unknown.
     pub fn get_artifact_versions(&self, artifact_id: Uuid) -> Result<Vec<ArtifactVersion>> {
-        Ok(self.get_artifact(artifact_id)?.versions)
+        self.get_artifact_versions_with_context(&RequestContext::development_admin(), artifact_id)
+    }
+
+    /// Get one artifact's version history under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing artifact, or scope errors.
+    pub fn get_artifact_versions_with_context(
+        &self,
+        context: &RequestContext,
+        artifact_id: Uuid,
+    ) -> Result<Vec<ArtifactVersion>> {
+        Ok(self
+            .get_artifact_with_context(context, artifact_id)?
+            .versions)
     }
 
     /// Get one artifact's metadata.
@@ -1139,7 +1350,21 @@ impl ModuleGenerationService {
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the artifact id is unknown.
     pub fn get_artifact_metadata(&self, artifact_id: Uuid) -> Result<ArtifactMetadata> {
-        Ok(self.get_artifact(artifact_id)?.artifact_metadata)
+        self.get_artifact_metadata_with_context(&RequestContext::development_admin(), artifact_id)
+    }
+
+    /// Get one artifact's metadata under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing artifact, or scope errors.
+    pub fn get_artifact_metadata_with_context(
+        &self,
+        context: &RequestContext,
+        artifact_id: Uuid,
+    ) -> Result<ArtifactMetadata> {
+        Ok(self
+            .get_artifact_with_context(context, artifact_id)?
+            .artifact_metadata)
     }
 
     /// Get one artifact's storage binding.
@@ -1150,10 +1375,32 @@ impl ModuleGenerationService {
         &self,
         artifact_id: Uuid,
     ) -> Result<ArtifactStorageBinding> {
-        Ok(self.get_artifact(artifact_id)?.storage_binding)
+        self.get_artifact_storage_binding_with_context(
+            &RequestContext::development_admin(),
+            artifact_id,
+        )
     }
 
-    fn mutate_job<F>(&self, job_id: Uuid, mutate: F) -> Result<GenerationJob>
+    /// Get one artifact's storage binding under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing artifact, or scope errors.
+    pub fn get_artifact_storage_binding_with_context(
+        &self,
+        context: &RequestContext,
+        artifact_id: Uuid,
+    ) -> Result<ArtifactStorageBinding> {
+        Ok(self
+            .get_artifact_with_context(context, artifact_id)?
+            .storage_binding)
+    }
+
+    fn mutate_job<F>(
+        &self,
+        context: &RequestContext,
+        job_id: Uuid,
+        mutate: F,
+    ) -> Result<GenerationJob>
     where
         F: FnOnce(&mut GenerationJob) -> Result<Vec<AuditSpec>>,
     {
@@ -1163,8 +1410,11 @@ impl ModuleGenerationService {
                 .get(&job_id)
                 .cloned()
                 .ok_or_else(|| HarnessError::NotFound(format!("generation_job_id={job_id}")))?;
+            assert_job_scope(context, &draft)?;
             let audit_specs = mutate(&mut draft)?;
             draft.updated_at = Utc::now();
+            draft.context = context.clone();
+            draft.version = draft.version.saturating_add(1);
             jobs.insert(job_id, draft.clone());
             drop(jobs);
             (draft, audit_specs)
@@ -1196,11 +1446,24 @@ impl ModuleGenerationService {
             target_type: "generation_job".to_owned(),
             target_id: job.id.to_string(),
             summary: summary.to_owned(),
-            metadata,
+            metadata: with_context_metadata(metadata, &job.context),
         });
     }
 }
 
+fn with_context_metadata(
+    mut metadata: serde_json::Value,
+    context: &RequestContext,
+) -> serde_json::Value {
+    if let Some(object) = metadata.as_object_mut() {
+        object
+            .entry("context")
+            .or_insert_with(|| context.audit_json());
+        return metadata;
+    }
+    json!({ "value": metadata, "context": context.audit_json() })
+}
+
 struct AuditSpec {
     action: AuditEventKind,
     actor: String,
@@ -1408,11 +1671,17 @@ fn generated_artifact(
         mime_type,
         size_bytes: object.size_bytes,
         owner: job.actor.clone(),
+        tenant_id: job.context.tenant_id.clone(),
+        project_id: job.context.project_id.clone(),
+        version: 1,
+        request_id: job.context.request_id.clone(),
+        correlation_id: job.context.correlation_id.clone(),
         source_job_id: Some(job.id),
         created_by_job_id: Some(job.id),
         approval_status: status,
         audit_event_id: None,
         created_at: object.created_at,
+        updated_at: object.updated_at,
     };
     let reference = ArtifactRef {
         artifact_id: id,
@@ -1445,6 +1714,7 @@ fn generated_artifact(
             "modelCalls": 0,
             "generator": "mock_generator_v1",
             "evaluator": "mock_evaluator_v1",
+            "context": job.context.audit_json(),
             "compression": compression_metadata_for(job.mode),
             "sceneTiles": scene_tiles_metadata_for(kind)
         }),
@@ -1553,28 +1823,69 @@ const fn viewer_adapter_hint_for(kind: ArtifactKind) -> Option<ViewerAdapterHint
 }
 
 fn set_generated_artifact_status(job: &mut GenerationJob, status: ArtifactStatus) {
+    let now = Utc::now();
     for artifact in &mut job.artifacts {
         if artifact.artifact_metadata.source_job_id == Some(job.id) {
-            set_artifact_status(artifact, status);
+            set_artifact_status(artifact, status, now);
         }
     }
     if let Some(output) = &mut job.output {
         for artifact in &mut output.artifacts {
-            set_artifact_status(artifact, status);
+            set_artifact_status(artifact, status, now);
         }
     }
 }
 
-fn set_artifact_status(artifact: &mut Artifact, status: ArtifactStatus) {
+fn set_artifact_status(artifact: &mut Artifact, status: ArtifactStatus, now: DateTime<Utc>) {
     artifact.status = status;
     artifact.reference.status = status;
+    artifact.version = artifact.version.saturating_add(1);
     artifact.artifact_metadata.approval_status = status;
+    artifact.artifact_metadata.version = artifact.artifact_metadata.version.saturating_add(1);
+    artifact.artifact_metadata.updated_at = now;
     if let Some(version) = artifact.versions.last_mut() {
         version.status = status;
         version.metadata.approval_status = status;
+        version.metadata.version = version.metadata.version.saturating_add(1);
+        version.metadata.updated_at = now;
+    }
+}
+
+fn stamp_artifact_context(artifact: &mut Artifact, context: &RequestContext) {
+    artifact
+        .artifact_metadata
+        .tenant_id
+        .clone_from(&context.tenant_id);
+    artifact
+        .artifact_metadata
+        .project_id
+        .clone_from(&context.project_id);
+    artifact
+        .artifact_metadata
+        .request_id
+        .clone_from(&context.request_id);
+    artifact
+        .artifact_metadata
+        .correlation_id
+        .clone_from(&context.correlation_id);
+    if let Some(object) = artifact.metadata.as_object_mut() {
+        object.insert("context".to_owned(), context.audit_json());
+    }
+    for version in &mut artifact.versions {
+        version.metadata.tenant_id.clone_from(&context.tenant_id);
+        version.metadata.project_id.clone_from(&context.project_id);
+        version.metadata.request_id.clone_from(&context.request_id);
+        version
+            .metadata
+            .correlation_id
+            .clone_from(&context.correlation_id);
     }
 }
 
+fn assert_job_scope(context: &RequestContext, job: &GenerationJob) -> Result<()> {
+    assert_runtime_scope(context, &job.context.tenant_id, &job.context.project_id)
+}
+
 fn transition_lifecycle(
     lifecycle: &ModuleLifecycleService,
     transaction_id: Option<Uuid>,
@@ -1778,6 +2089,7 @@ mod tests {
     use crate::module_lifecycle::{
         ApprovalDecisionRequest, ModuleLifecycleService, ModuleTransactionStatus,
     };
+    use crate::runtime_context::{RequestContext, RequestContextInput, RuntimeProfile};
     use crate::storage_router::{
         ArtifactMetadata, ArtifactRef, ArtifactRole, ArtifactStatus, ArtifactStorageBinding,
         ArtifactVersion, ElementIdNamespace, GeometryFormat, PropertyIndexFormat,
@@ -1821,6 +2133,21 @@ mod tests {
         }
     }
 
+    fn context(tenant_id: &str, project_id: &str, actor: &str, roles: &[&str]) -> RequestContext {
+        RequestContext::from_input(
+            RequestContextInput {
+                tenant_id: Some(tenant_id.to_owned()),
+                project_id: Some(project_id.to_owned()),
+                actor: Some(actor.to_owned()),
+                roles: Some(roles.iter().map(|role| (*role).to_owned()).collect()),
+                request_id: Some(format!("req-{actor}")),
+                correlation_id: Some(format!("corr-{actor}")),
+            },
+            RuntimeProfile::Production,
+        )
+        .expect("context should parse")
+    }
+
     fn run_to_pending_review(
         service: &ModuleGenerationService,
         mode: GenerationMode,
@@ -1988,6 +2315,153 @@ mod tests {
         );
     }
 
+    #[test]
+    fn unauthorized_generation_create_returns_permission_denied_without_mutation() {
+        let (service, _audit) = service();
+        let auditor = context("tenant-a", "project-a", "auditor", &["auditor"]);
+        let err = service
+            .create_job_with_context(&auditor, input(GenerationMode::TextToBim))
+            .expect_err("auditor cannot create generation jobs");
+        assert_eq!(err.http_status(), 403);
+
+        let page = service
+            .list_jobs_with_context(&auditor, &GenerationJobQuery::default())
+            .expect("auditor can list");
+        assert!(page.items.is_empty());
+    }
+
+    #[test]
+    fn engineer_can_create_and_run_but_not_approve() {
+        let (service, _audit) = service();
+        let engineer = context("tenant-a", "project-a", "engineer", &["engineer"]);
+        let job = service
+            .create_job_with_context(&engineer, input(GenerationMode::ModelToLightweightScene))
+            .expect("engineer can create");
+        let job = service
+            .plan_job_with_context(&engineer, job.id, GenerationActionRequest::default())
+            .expect("engineer can plan");
+        let job = service
+            .run_job_with_context(&engineer, job.id, GenerationActionRequest::default())
+            .expect("engineer can run");
+        assert_eq!(job.status, GenerationJobStatus::PendingReview);
+
+        let err = service
+            .approve_job_with_context(&engineer, job.id, GenerationActionRequest::default())
+            .expect_err("engineer cannot approve");
+        assert_eq!(err.http_status(), 403);
+        assert_eq!(
+            service
+                .get_job_with_context(&engineer, job.id)
+                .expect("job still readable")
+                .status,
+            GenerationJobStatus::PendingReview
+        );
+    }
+
+    #[test]
+    fn reviewer_can_review_and_approve_but_not_create() {
+        let (service, _audit) = service();
+        let engineer = context("tenant-a", "project-a", "engineer", &["engineer"]);
+        let reviewer = context("tenant-a", "project-a", "reviewer", &["reviewer"]);
+        let err = service
+            .create_job_with_context(&reviewer, input(GenerationMode::TextToBim))
+            .expect_err("reviewer cannot create");
+        assert_eq!(err.http_status(), 403);
+
+        let job = service
+            .create_job_with_context(&engineer, input(GenerationMode::TextToBim))
+            .expect("engineer can create");
+        let job = service
+            .plan_job_with_context(&engineer, job.id, GenerationActionRequest::default())
+            .and_then(|planned| {
+                service.run_job_with_context(
+                    &engineer,
+                    planned.id,
+                    GenerationActionRequest::default(),
+                )
+            })
+            .expect("engineer can run");
+        let job = service
+            .review_job_with_context(
+                &reviewer,
+                job.id,
+                GenerationReviewRequest {
+                    reviewer: String::new(),
+                    decision: GenerationReviewDecision::Approved,
+                    comment: None,
+                },
+            )
+            .expect("reviewer can review");
+        let approved = service
+            .approve_job_with_context(&reviewer, job.id, GenerationActionRequest::default())
+            .expect("reviewer can approve");
+        assert_eq!(approved.status, GenerationJobStatus::Approved);
+    }
+
+    #[test]
+    fn auditor_can_list_and_read_but_not_write() {
+        let (service, _audit) = service();
+        let engineer = context("tenant-a", "project-a", "engineer", &["engineer"]);
+        let auditor = context("tenant-a", "project-a", "auditor", &["auditor"]);
+        let job = service
+            .create_job_with_context(&engineer, input(GenerationMode::TextToImage))
+            .expect("engineer can create");
+
+        assert!(
+            service
+                .list_jobs_with_context(&auditor, &GenerationJobQuery::default())
+                .expect("auditor can list")
+                .items
+                .iter()
+                .any(|listed| listed.id == job.id)
+        );
+        assert!(service.get_job_with_context(&auditor, job.id).is_ok());
+        let err = service
+            .run_job_with_context(&auditor, job.id, GenerationActionRequest::default())
+            .expect_err("auditor cannot run");
+        assert_eq!(err.http_status(), 403);
+    }
+
+    #[test]
+    fn generation_and_artifact_lists_are_tenant_project_isolated() {
+        let (service, _audit) = service();
+        let tenant_a = context("tenant-a", "project-a", "engineer-a", &["engineer"]);
+        let tenant_b = context("tenant-b", "project-a", "engineer-b", &["engineer"]);
+        let job_a = service
+            .create_job_with_context(&tenant_a, input(GenerationMode::ModelToLightweightScene))
+            .expect("tenant a job");
+        let job_a = service
+            .plan_job_with_context(&tenant_a, job_a.id, GenerationActionRequest::default())
+            .and_then(|planned| {
+                service.run_job_with_context(
+                    &tenant_a,
+                    planned.id,
+                    GenerationActionRequest::default(),
+                )
+            })
+            .expect("tenant a run");
+        let job_b = service
+            .create_job_with_context(&tenant_b, input(GenerationMode::TextToImage))
+            .expect("tenant b job");
+
+        let list_b = service
+            .list_jobs_with_context(&tenant_b, &GenerationJobQuery::default())
+            .expect("tenant b can list");
+        assert_eq!(list_b.items.len(), 1);
+        assert_eq!(list_b.items[0].id, job_b.id);
+
+        let artifacts_b = service
+            .list_indexed_artifacts_with_context(&tenant_b, &ArtifactListQuery::default())
+            .expect("tenant b artifact list");
+        assert!(artifacts_b.items.is_empty());
+
+        let artifact_id = job_a.artifacts[0].id;
+        let err = service
+            .get_artifact_with_context(&tenant_b, artifact_id)
+            .expect_err("cross tenant artifact get is forbidden");
+        assert_eq!(err.http_status(), 403);
+    }
+
     #[test]
     fn conversion_matrix_covers_required_modes() {
         assert_eq!(GenerationMode::ALL.len(), 42);
@@ -2657,11 +3131,17 @@ mod tests {
             mime_type: "model/ifc".to_owned(),
             size_bytes: 0,
             owner: "planner".to_owned(),
+            tenant_id: "dev-tenant".to_owned(),
+            project_id: "dev-project".to_owned(),
+            version: 1,
+            request_id: "dev-request".to_owned(),
+            correlation_id: "dev-correlation".to_owned(),
             source_job_id: None,
             created_by_job_id: None,
             approval_status: ArtifactStatus::Draft,
             audit_event_id: None,
             created_at: now,
+            updated_at: now,
         };
         req.input_artifacts = Some(vec![Artifact {
             id: artifact_id,
diff --git a/04-backend/harness-core/src/runtime_capabilities.rs b/04-backend/harness-core/src/runtime_capabilities.rs
index c45ad7b3..465c1f2c 100644
--- a/04-backend/harness-core/src/runtime_capabilities.rs
+++ b/04-backend/harness-core/src/runtime_capabilities.rs
@@ -27,6 +27,8 @@ pub struct RuntimeCapabilities {
     pub registry: RuntimeRegistryCapabilities,
     /// Storage adapter availability.
     pub storage: RuntimeStorageCapabilities,
+    /// Durable store boundary availability.
+    pub store_capabilities: RuntimeStoreCapabilities,
     /// Local implementation mode.
     pub local_implementation_mode: String,
     /// Production caveats clients should show in developer consoles.
@@ -57,6 +59,31 @@ pub struct RuntimeStorageCapabilities {
     pub production_ready: bool,
 }
 
+/// Durable store boundary flags for the current runtime.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+#[allow(clippy::struct_excessive_bools)]
+pub struct RuntimeStoreCapabilities {
+    /// `ObjectStore` boundary is present.
+    pub object_store: bool,
+    /// `TransactionStore` boundary is present.
+    pub transaction_store: bool,
+    /// `EventStore` boundary is present.
+    pub event_store: bool,
+    /// `RegistryStore` boundary is present.
+    pub registry_store: bool,
+    /// `ArtifactStore` boundary is present.
+    pub artifact_store: bool,
+    /// `ViewerCommandStore` boundary is present.
+    pub viewer_command_store: bool,
+    /// `KnowledgeSourceStore` boundary is present.
+    pub knowledge_source_store: bool,
+    /// Whether current adapters are in-memory only.
+    pub in_memory_only: bool,
+    /// Whether list APIs use deterministic ordering before pagination.
+    pub deterministic_pagination: bool,
+}
+
 /// Viewer capability hints.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -116,6 +143,17 @@ impl RuntimeCapabilities {
                 persists_real_bytes: false,
                 production_ready: false,
             },
+            store_capabilities: RuntimeStoreCapabilities {
+                object_store: true,
+                transaction_store: true,
+                event_store: true,
+                registry_store: true,
+                artifact_store: true,
+                viewer_command_store: true,
+                knowledge_source_store: true,
+                in_memory_only: true,
+                deterministic_pagination: true,
+            },
             local_implementation_mode: "in_memory_preview".to_owned(),
             production_caveats: vec![
                 "No real commercial model APIs are connected.".to_owned(),
@@ -149,6 +187,8 @@ mod tests {
                 .providers
                 .contains(&"memory".to_owned())
         );
+        assert!(capabilities.store_capabilities.artifact_store);
+        assert!(capabilities.store_capabilities.deterministic_pagination);
         assert!(
             capabilities
                 .viewer
diff --git a/04-backend/harness-core/src/runtime_context.rs b/04-backend/harness-core/src/runtime_context.rs
new file mode 100644
index 00000000..0d7b400e
--- /dev/null
+++ b/04-backend/harness-core/src/runtime_context.rs
@@ -0,0 +1,597 @@
+//! Runtime request context, tenant/project scope, and preview RBAC guard.
+//!
+//! This module is deliberately adapter-free. It models the durable runtime
+//! boundary used by HTTP handlers and in-memory services today, while leaving
+//! JWT, database-backed policy, and external identity providers replaceable.
+
+use std::{collections::HashSet, fmt};
+
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use crate::{
+    error::{HarnessError, Result},
+    storage_router::StoreRecordMetadata,
+};
+
+/// Header carrying the active tenant id.
+pub const HEADER_TENANT_ID: &str = "x-tenant-id";
+/// Header carrying the active project id.
+pub const HEADER_PROJECT_ID: &str = "x-project-id";
+/// Header carrying the actor id.
+pub const HEADER_ACTOR: &str = "x-actor";
+/// Header carrying comma-separated runtime roles.
+pub const HEADER_ROLES: &str = "x-roles";
+/// Header carrying the request id.
+pub const HEADER_REQUEST_ID: &str = "x-request-id";
+/// Header carrying the correlation id.
+pub const HEADER_CORRELATION_ID: &str = "x-correlation-id";
+
+const DEV_TENANT_ID: &str = "dev-tenant";
+const DEV_PROJECT_ID: &str = "dev-project";
+const DEV_ACTOR: &str = "dev-actor";
+
+/// Runtime profile used to decide whether weak dev context fallback is allowed.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RuntimeProfile {
+    /// Local development preview. Missing context may use deterministic dev fallback.
+    Development,
+    /// Production-like profile. Tenant/project/actor/roles must be explicit.
+    Production,
+}
+
+impl RuntimeProfile {
+    /// Build a profile from `INSOMEOS_PROFILE` or equivalent config value.
+    #[must_use]
+    pub fn from_profile_name(value: &str) -> Self {
+        match value {
+            "production" | "prod" | "staging" | "preview" => Self::Production,
+            _ => Self::Development,
+        }
+    }
+
+    /// Whether weak local fallback is allowed.
+    #[must_use]
+    pub const fn allows_weak_fallback(self) -> bool {
+        matches!(self, Self::Development)
+    }
+}
+
+/// Runtime RBAC role used by Phase 6 preview policy.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum RuntimeRole {
+    /// Full access.
+    Admin,
+    /// Engineering author allowed to create/run/write preview resources.
+    Engineer,
+    /// Reviewer allowed to review/approve/read resources.
+    Reviewer,
+    /// Read-only auditor.
+    Auditor,
+}
+
+impl RuntimeRole {
+    /// Parse a role string from headers/query/body values.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::InvalidInput`] when the role is unknown.
+    pub fn parse(value: &str) -> Result<Self> {
+        match value.trim().to_ascii_lowercase().as_str() {
+            "admin" => Ok(Self::Admin),
+            "engineer" => Ok(Self::Engineer),
+            "reviewer" => Ok(Self::Reviewer),
+            "auditor" => Ok(Self::Auditor),
+            unknown => Err(HarnessError::InvalidInput(format!(
+                "unknown runtime role: {unknown}"
+            ))),
+        }
+    }
+}
+
+impl fmt::Display for RuntimeRole {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let value = match self {
+            Self::Admin => "admin",
+            Self::Engineer => "engineer",
+            Self::Reviewer => "reviewer",
+            Self::Auditor => "auditor",
+        };
+        f.write_str(value)
+    }
+}
+
+/// Runtime permission checked by the Phase 6 preview guard.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum RuntimePermission {
+    /// `artifact:read`.
+    #[serde(rename = "artifact:read")]
+    ArtifactRead,
+    /// `artifact:write`.
+    #[serde(rename = "artifact:write")]
+    ArtifactWrite,
+    /// `generation:create`.
+    #[serde(rename = "generation:create")]
+    GenerationCreate,
+    /// `generation:run`.
+    #[serde(rename = "generation:run")]
+    GenerationRun,
+    /// `generation:review`.
+    #[serde(rename = "generation:review")]
+    GenerationReview,
+    /// `generation:approve`.
+    #[serde(rename = "generation:approve")]
+    GenerationApprove,
+    /// `registry:read`.
+    #[serde(rename = "registry:read")]
+    RegistryRead,
+    /// `registry:write`.
+    #[serde(rename = "registry:write")]
+    RegistryWrite,
+    /// `registry:approve`.
+    #[serde(rename = "registry:approve")]
+    RegistryApprove,
+    /// `viewer:command:create`.
+    #[serde(rename = "viewer:command:create")]
+    ViewerCommandCreate,
+    /// `viewer:command:ack`.
+    #[serde(rename = "viewer:command:ack")]
+    ViewerCommandAck,
+    /// `knowledge:ingest`.
+    #[serde(rename = "knowledge:ingest")]
+    KnowledgeIngest,
+}
+
+impl fmt::Display for RuntimePermission {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let value = match self {
+            Self::ArtifactRead => "artifact:read",
+            Self::ArtifactWrite => "artifact:write",
+            Self::GenerationCreate => "generation:create",
+            Self::GenerationRun => "generation:run",
+            Self::GenerationReview => "generation:review",
+            Self::GenerationApprove => "generation:approve",
+            Self::RegistryRead => "registry:read",
+            Self::RegistryWrite => "registry:write",
+            Self::RegistryApprove => "registry:approve",
+            Self::ViewerCommandCreate => "viewer:command:create",
+            Self::ViewerCommandAck => "viewer:command:ack",
+            Self::KnowledgeIngest => "knowledge:ingest",
+        };
+        f.write_str(value)
+    }
+}
+
+/// Context fields accepted from headers, query params, or request bodies.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct RequestContextInput {
+    /// Tenant id candidate.
+    pub tenant_id: Option<String>,
+    /// Project id candidate.
+    pub project_id: Option<String>,
+    /// Actor candidate.
+    pub actor: Option<String>,
+    /// Runtime roles candidate.
+    pub roles: Option<Vec<String>>,
+    /// Request id candidate.
+    pub request_id: Option<String>,
+    /// Correlation id candidate.
+    pub correlation_id: Option<String>,
+}
+
+impl RequestContextInput {
+    /// Fill unset fields from a lower-priority source.
+    #[must_use]
+    pub fn with_fallback(mut self, fallback: &Self) -> Self {
+        if self.tenant_id.is_none() {
+            self.tenant_id.clone_from(&fallback.tenant_id);
+        }
+        if self.project_id.is_none() {
+            self.project_id.clone_from(&fallback.project_id);
+        }
+        if self.actor.is_none() {
+            self.actor.clone_from(&fallback.actor);
+        }
+        if self.roles.is_none() {
+            self.roles.clone_from(&fallback.roles);
+        }
+        if self.request_id.is_none() {
+            self.request_id.clone_from(&fallback.request_id);
+        }
+        if self.correlation_id.is_none() {
+            self.correlation_id.clone_from(&fallback.correlation_id);
+        }
+        self
+    }
+}
+
+/// Tenant/project/actor context carried through runtime services.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RequestContext {
+    /// Tenant id.
+    pub tenant_id: String,
+    /// Project id.
+    pub project_id: String,
+    /// Actor id.
+    pub actor: String,
+    /// Runtime roles.
+    pub roles: Vec<RuntimeRole>,
+    /// Request id.
+    pub request_id: String,
+    /// Correlation id.
+    pub correlation_id: String,
+}
+
+impl RequestContext {
+    /// Deterministic local dev admin context used by legacy unit tests.
+    #[must_use]
+    pub fn development_admin() -> Self {
+        Self {
+            tenant_id: DEV_TENANT_ID.to_owned(),
+            project_id: DEV_PROJECT_ID.to_owned(),
+            actor: DEV_ACTOR.to_owned(),
+            roles: vec![RuntimeRole::Admin],
+            request_id: "dev-request".to_owned(),
+            correlation_id: "dev-correlation".to_owned(),
+        }
+    }
+
+    /// Build a context from merged request inputs.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::InvalidInput`] when required production context
+    /// fields are missing or role names are unknown.
+    pub fn from_input(input: RequestContextInput, profile: RuntimeProfile) -> Result<Self> {
+        let allow_fallback = profile.allows_weak_fallback();
+        let tenant_id =
+            required_or_dev(input.tenant_id, "tenant_id", DEV_TENANT_ID, allow_fallback)?;
+        let project_id = required_or_dev(
+            input.project_id,
+            "project_id",
+            DEV_PROJECT_ID,
+            allow_fallback,
+        )?;
+        let actor = required_or_dev(input.actor, "actor", DEV_ACTOR, allow_fallback)?;
+        let roles = match input.roles {
+            Some(values) if !values.is_empty() => parse_roles(values)?,
+            Some(_) | None if allow_fallback => vec![RuntimeRole::Admin],
+            Some(_) | None => {
+                return Err(HarnessError::InvalidInput(
+                    "roles are required in production runtime context".to_owned(),
+                ));
+            }
+        };
+        Ok(Self {
+            tenant_id,
+            project_id,
+            actor,
+            roles,
+            request_id: optional_or_generated(input.request_id, "request"),
+            correlation_id: optional_or_generated(input.correlation_id, "correlation"),
+        })
+    }
+
+    /// Convert context to durable-store metadata.
+    #[must_use]
+    pub fn store_metadata(&self, owner: impl Into<String>) -> StoreRecordMetadata {
+        StoreRecordMetadata::new(
+            owner.into(),
+            self.tenant_id.clone(),
+            self.project_id.clone(),
+            self.request_id.clone(),
+            self.correlation_id.clone(),
+        )
+    }
+
+    /// JSON representation used in audit payloads and artifact metadata.
+    #[must_use]
+    pub fn audit_json(&self) -> serde_json::Value {
+        serde_json::json!({
+            "tenantId": self.tenant_id,
+            "projectId": self.project_id,
+            "actor": self.actor,
+            "roles": self.roles.iter().map(ToString::to_string).collect::<Vec<_>>(),
+            "requestId": self.request_id,
+            "correlationId": self.correlation_id
+        })
+    }
+}
+
+/// Permission decision emitted by the preview guard.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PermissionDecision {
+    /// Whether the permission was allowed.
+    pub allowed: bool,
+    /// Permission being checked.
+    pub permission: RuntimePermission,
+    /// Actor being checked.
+    pub actor: String,
+    /// Roles used for the decision.
+    pub roles: Vec<RuntimeRole>,
+    /// Tenant id.
+    pub tenant_id: String,
+    /// Project id.
+    pub project_id: String,
+    /// Request id.
+    pub request_id: String,
+    /// Correlation id.
+    pub correlation_id: String,
+    /// Optional denial reason.
+    pub reason: Option<String>,
+}
+
+impl PermissionDecision {
+    fn from_context(
+        context: &RequestContext,
+        permission: RuntimePermission,
+        allowed: bool,
+        reason: Option<String>,
+    ) -> Self {
+        Self {
+            allowed,
+            permission,
+            actor: context.actor.clone(),
+            roles: context.roles.clone(),
+            tenant_id: context.tenant_id.clone(),
+            project_id: context.project_id.clone(),
+            request_id: context.request_id.clone(),
+            correlation_id: context.correlation_id.clone(),
+            reason,
+        }
+    }
+}
+
+/// In-memory role policy used until a durable policy store is wired.
+#[derive(Debug, Clone, Default)]
+pub struct PermissionGuard;
+
+impl PermissionGuard {
+    /// Return the decision for a permission check without throwing.
+    #[must_use]
+    pub fn decide(context: &RequestContext, permission: RuntimePermission) -> PermissionDecision {
+        let allowed = allowed_permissions(&context.roles).contains(&permission);
+        let reason = if allowed {
+            None
+        } else {
+            Some(format!(
+                "permission {permission} denied for actor {} roles {:?}",
+                context.actor, context.roles
+            ))
+        };
+        PermissionDecision::from_context(context, permission, allowed, reason)
+    }
+
+    /// Ensure the context is allowed to perform a permission.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::SandboxDenied`] with HTTP 403 when denied.
+    pub fn ensure(
+        context: &RequestContext,
+        permission: RuntimePermission,
+    ) -> Result<PermissionDecision> {
+        let decision = Self::decide(context, permission);
+        if decision.allowed {
+            return Ok(decision);
+        }
+        Err(HarnessError::SandboxDenied(
+            serde_json::to_string(&decision).unwrap_or_else(|_| {
+                format!("permission {permission} denied for actor {}", context.actor)
+            }),
+        ))
+    }
+}
+
+/// Assert a record belongs to the request tenant/project.
+///
+/// # Errors
+/// Returns [`HarnessError::TenantIsolation`] with HTTP 403 when scoped ids differ.
+pub fn assert_runtime_scope(
+    context: &RequestContext,
+    tenant_id: &str,
+    project_id: &str,
+) -> Result<()> {
+    if context.tenant_id == tenant_id && context.project_id == project_id {
+        return Ok(());
+    }
+    Err(HarnessError::TenantIsolation(format!(
+        "actor {} cannot access tenant/project {tenant_id}/{project_id}",
+        context.actor
+    )))
+}
+
+/// Parse comma-separated or repeated role values.
+///
+/// # Errors
+/// Returns [`HarnessError::InvalidInput`] for unknown role names.
+pub fn parse_roles(values: Vec<String>) -> Result<Vec<RuntimeRole>> {
+    let mut roles = Vec::new();
+    for value in values {
+        for role in value.split(',') {
+            let trimmed = role.trim();
+            if !trimmed.is_empty() {
+                roles.push(RuntimeRole::parse(trimmed)?);
+            }
+        }
+    }
+    if roles.is_empty() {
+        return Err(HarnessError::InvalidInput(
+            "at least one runtime role is required".to_owned(),
+        ));
+    }
+    roles.sort_by_key(ToString::to_string);
+    roles.dedup();
+    Ok(roles)
+}
+
+fn allowed_permissions(roles: &[RuntimeRole]) -> HashSet<RuntimePermission> {
+    use RuntimePermission::{
+        ArtifactRead, ArtifactWrite, GenerationApprove, GenerationCreate, GenerationReview,
+        GenerationRun, KnowledgeIngest, RegistryApprove, RegistryRead, RegistryWrite,
+        ViewerCommandAck, ViewerCommandCreate,
+    };
+
+    let mut permissions = HashSet::new();
+    for role in roles {
+        match role {
+            RuntimeRole::Admin => {
+                permissions.extend([
+                    ArtifactRead,
+                    ArtifactWrite,
+                    GenerationCreate,
+                    GenerationRun,
+                    GenerationReview,
+                    GenerationApprove,
+                    RegistryRead,
+                    RegistryWrite,
+                    RegistryApprove,
+                    ViewerCommandCreate,
+                    ViewerCommandAck,
+                    KnowledgeIngest,
+                ]);
+            }
+            RuntimeRole::Engineer => {
+                permissions.extend([
+                    ArtifactRead,
+                    ArtifactWrite,
+                    GenerationCreate,
+                    GenerationRun,
+                    RegistryRead,
+                    RegistryWrite,
+                    ViewerCommandCreate,
+                ]);
+            }
+            RuntimeRole::Reviewer => {
+                permissions.extend([
+                    ArtifactRead,
+                    GenerationReview,
+                    GenerationApprove,
+                    RegistryRead,
+                    RegistryApprove,
+                ]);
+            }
+            RuntimeRole::Auditor => {
+                permissions.extend([ArtifactRead, RegistryRead]);
+            }
+        }
+    }
+    permissions
+}
+
+fn required_or_dev(
+    value: Option<String>,
+    field: &str,
+    dev_value: &str,
+    allow_fallback: bool,
+) -> Result<String> {
+    let trimmed = value.and_then(|candidate| {
+        let trimmed = candidate.trim().to_owned();
+        (!trimmed.is_empty()).then_some(trimmed)
+    });
+    if let Some(value) = trimmed {
+        return Ok(value);
+    }
+    if allow_fallback {
+        return Ok(dev_value.to_owned());
+    }
+    Err(HarnessError::InvalidInput(format!(
+        "{field} is required in production runtime context"
+    )))
+}
+
+fn optional_or_generated(value: Option<String>, prefix: &str) -> String {
+    value
+        .and_then(|candidate| {
+            let trimmed = candidate.trim().to_owned();
+            (!trimmed.is_empty()).then_some(trimmed)
+        })
+        .unwrap_or_else(|| format!("{prefix}-{}", Uuid::new_v4()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        PermissionGuard, RequestContext, RequestContextInput, RuntimePermission, RuntimeProfile,
+        RuntimeRole, assert_runtime_scope,
+    };
+
+    #[test]
+    fn context_header_body_fallback_parsing() {
+        let header = RequestContextInput {
+            tenant_id: Some("tenant-a".to_owned()),
+            project_id: Some("project-a".to_owned()),
+            actor: None,
+            roles: None,
+            request_id: Some("req-1".to_owned()),
+            correlation_id: None,
+        };
+        let body = RequestContextInput {
+            actor: Some("body-actor".to_owned()),
+            roles: Some(vec!["engineer,reviewer".to_owned()]),
+            correlation_id: Some("corr-1".to_owned()),
+            ..RequestContextInput::default()
+        };
+        let context =
+            RequestContext::from_input(header.with_fallback(&body), RuntimeProfile::Development)
+                .expect("context should parse");
+        assert_eq!(context.tenant_id, "tenant-a");
+        assert_eq!(context.project_id, "project-a");
+        assert_eq!(context.actor, "body-actor");
+        assert_eq!(
+            context.roles,
+            vec![RuntimeRole::Engineer, RuntimeRole::Reviewer]
+        );
+        assert_eq!(context.request_id, "req-1");
+        assert_eq!(context.correlation_id, "corr-1");
+    }
+
+    #[test]
+    fn production_profile_rejects_weak_context_fallback() {
+        let err = RequestContext::from_input(
+            RequestContextInput {
+                tenant_id: Some("tenant-a".to_owned()),
+                ..RequestContextInput::default()
+            },
+            RuntimeProfile::Production,
+        )
+        .expect_err("project/actor/roles should be required");
+        assert_eq!(err.http_status(), 400);
+    }
+
+    #[test]
+    fn role_policy_matches_phase6_contract() {
+        let mut context = RequestContext::development_admin();
+        context.roles = vec![RuntimeRole::Engineer];
+        assert!(PermissionGuard::ensure(&context, RuntimePermission::GenerationCreate).is_ok());
+        assert!(PermissionGuard::ensure(&context, RuntimePermission::GenerationApprove).is_err());
+
+        context.roles = vec![RuntimeRole::Reviewer];
+        assert!(PermissionGuard::ensure(&context, RuntimePermission::GenerationApprove).is_ok());
+        assert!(PermissionGuard::ensure(&context, RuntimePermission::GenerationCreate).is_err());
+
+        context.roles = vec![RuntimeRole::Auditor];
+        assert!(PermissionGuard::ensure(&context, RuntimePermission::ArtifactRead).is_ok());
+        assert!(PermissionGuard::ensure(&context, RuntimePermission::RegistryWrite).is_err());
+    }
+
+    #[test]
+    fn tenant_project_scope_is_enforced() {
+        let context = RequestContext::from_input(
+            RequestContextInput {
+                tenant_id: Some("tenant-a".to_owned()),
+                project_id: Some("project-a".to_owned()),
+                actor: Some("actor-a".to_owned()),
+                roles: Some(vec!["admin".to_owned()]),
+                ..RequestContextInput::default()
+            },
+            RuntimeProfile::Production,
+        )
+        .expect("context should parse");
+        assert!(assert_runtime_scope(&context, "tenant-a", "project-a").is_ok());
+        let err =
+            assert_runtime_scope(&context, "tenant-b", "project-a").expect_err("scope mismatch");
+        assert_eq!(err.http_status(), 403);
+    }
+}
diff --git a/04-backend/harness-core/src/skill_registry.rs b/04-backend/harness-core/src/skill_registry.rs
index 3f4e722f..4ae65456 100644
--- a/04-backend/harness-core/src/skill_registry.rs
+++ b/04-backend/harness-core/src/skill_registry.rs
@@ -13,6 +13,7 @@ use serde::{Deserialize, Serialize};
 use crate::{
     error::{HarnessError, Result},
     module_pagination::{ListPage, PageInfo, paginate},
+    runtime_context::{PermissionGuard, RequestContext, RuntimePermission, assert_runtime_scope},
 };
 
 const FORBIDDEN_LICENSES: &[&str] = &[
@@ -114,6 +115,20 @@ pub struct SkillSpec {
     pub name: String,
     /// Owner team or user id.
     pub owner: String,
+    /// Tenant id used for registry isolation.
+    pub tenant_id: String,
+    /// Project id used for registry isolation.
+    pub project_id: String,
+    /// Actor that created the registry record.
+    pub created_by: String,
+    /// Actor that last updated the registry record.
+    pub updated_by: String,
+    /// Monotonic in-memory registry record version.
+    pub record_version: u32,
+    /// Request id that created or last updated the record.
+    pub request_id: String,
+    /// Correlation id for the registry workflow.
+    pub correlation_id: String,
     /// Active version.
     pub version: SkillVersion,
     /// Input JSON schema reference.
@@ -241,6 +256,19 @@ impl SkillRegistryService {
     /// forbidden commercial licenses, and [`HarnessError::InvalidInput`] when
     /// the id already exists.
     pub fn create_skill(&self, req: CreateSkillRequest) -> Result<SkillSpec> {
+        self.create_skill_with_context(&RequestContext::development_admin(), req)
+    }
+
+    /// Create a draft skill under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, validation, license, or duplicate-id errors.
+    pub fn create_skill_with_context(
+        &self,
+        context: &RequestContext,
+        req: CreateSkillRequest,
+    ) -> Result<SkillSpec> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryWrite)?;
         validate_required("name", &req.name)?;
         validate_required("owner", &req.owner)?;
         validate_required("input_schema_ref", &req.input_schema_ref)?;
@@ -256,6 +284,13 @@ impl SkillRegistryService {
             id: id.clone(),
             name: req.name,
             owner: req.owner,
+            tenant_id: context.tenant_id.clone(),
+            project_id: context.project_id.clone(),
+            created_by: context.actor.clone(),
+            updated_by: context.actor.clone(),
+            record_version: 1,
+            request_id: context.request_id.clone(),
+            correlation_id: context.correlation_id.clone(),
             version: SkillVersion {
                 version: req.version,
                 changelog: "initial registry preview".to_owned(),
@@ -287,10 +322,26 @@ impl SkillRegistryService {
     /// # Errors
     /// Returns [`HarnessError::InvalidInput`] when pagination cursor is invalid.
     pub fn list_skills(&self, query: &SkillListQuery) -> Result<ListPage<SkillSpec>> {
+        self.list_skills_with_context(&RequestContext::development_admin(), query)
+    }
+
+    /// List skills visible to a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission or pagination errors.
+    pub fn list_skills_with_context(
+        &self,
+        context: &RequestContext,
+        query: &SkillListQuery,
+    ) -> Result<ListPage<SkillSpec>> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryRead)?;
         let mut items: Vec<SkillSpec> = self
             .skills
             .read()
             .values()
+            .filter(|skill| {
+                skill.tenant_id == context.tenant_id && skill.project_id == context.project_id
+            })
             .filter(|skill| query.status.is_none_or(|status| skill.status == status))
             .filter(|skill| {
                 query
@@ -309,11 +360,22 @@ impl SkillRegistryService {
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the skill id is unknown.
     pub fn get_skill(&self, skill_id: &str) -> Result<SkillSpec> {
-        self.skills
-            .read()
-            .get(skill_id)
-            .cloned()
-            .ok_or_else(|| HarnessError::NotFound(format!("skill_id={skill_id}")))
+        self.get_skill_with_context(&RequestContext::development_admin(), skill_id)
+    }
+
+    /// Get one skill visible to a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing record, or scope errors.
+    pub fn get_skill_with_context(
+        &self,
+        context: &RequestContext,
+        skill_id: &str,
+    ) -> Result<SkillSpec> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryRead)?;
+        let skill = self.get_skill_unscoped(skill_id)?;
+        assert_skill_scope(context, &skill)?;
+        Ok(skill)
     }
 
     /// Patch a skill.
@@ -322,10 +384,25 @@ impl SkillRegistryService {
     /// Returns [`HarnessError::NotFound`] when the skill id is unknown and
     /// [`HarnessError::InvalidInput`] for forbidden license policies.
     pub fn update_skill(&self, skill_id: &str, req: UpdateSkillRequest) -> Result<SkillSpec> {
+        self.update_skill_with_context(&RequestContext::development_admin(), skill_id, req)
+    }
+
+    /// Patch a skill under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing record, scope, validation, or license errors.
+    pub fn update_skill_with_context(
+        &self,
+        context: &RequestContext,
+        skill_id: &str,
+        req: UpdateSkillRequest,
+    ) -> Result<SkillSpec> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryWrite)?;
         if let Some(policy) = &req.license_policy {
             validate_license_policy(policy)?;
         }
-        let mut skill = self.get_skill(skill_id)?;
+        let mut skill = self.get_skill_unscoped(skill_id)?;
+        assert_skill_scope(context, &skill)?;
         if let Some(name) = req.name {
             validate_required("name", &name)?;
             skill.name = name;
@@ -356,6 +433,10 @@ impl SkillRegistryService {
         if let Some(fixtures) = req.fixtures {
             skill.fixtures = fixtures;
         }
+        skill.updated_by.clone_from(&context.actor);
+        skill.record_version = skill.record_version.saturating_add(1);
+        skill.request_id.clone_from(&context.request_id);
+        skill.correlation_id.clone_from(&context.correlation_id);
         skill.updated_at = Utc::now();
         self.skills
             .write()
@@ -368,11 +449,30 @@ impl SkillRegistryService {
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the skill id is unknown and
     /// [`HarnessError::InvalidInput`] for forbidden license policies.
-    pub fn approve_skill(&self, skill_id: &str, _req: RegistryActionRequest) -> Result<SkillSpec> {
-        let mut skill = self.get_skill(skill_id)?;
+    pub fn approve_skill(&self, skill_id: &str, req: RegistryActionRequest) -> Result<SkillSpec> {
+        self.approve_skill_with_context(&RequestContext::development_admin(), skill_id, req)
+    }
+
+    /// Approve a skill for production routing under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing record, scope, or license errors.
+    pub fn approve_skill_with_context(
+        &self,
+        context: &RequestContext,
+        skill_id: &str,
+        _req: RegistryActionRequest,
+    ) -> Result<SkillSpec> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryApprove)?;
+        let mut skill = self.get_skill_unscoped(skill_id)?;
+        assert_skill_scope(context, &skill)?;
         validate_license_policy(&skill.license_policy)?;
         skill.status = SkillStatus::Approved;
         skill.production_route_enabled = true;
+        skill.updated_by.clone_from(&context.actor);
+        skill.record_version = skill.record_version.saturating_add(1);
+        skill.request_id.clone_from(&context.request_id);
+        skill.correlation_id.clone_from(&context.correlation_id);
         skill.updated_at = Utc::now();
         self.skills
             .write()
@@ -384,10 +484,29 @@ impl SkillRegistryService {
     ///
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the skill id is unknown.
-    pub fn disable_skill(&self, skill_id: &str, _req: RegistryActionRequest) -> Result<SkillSpec> {
-        let mut skill = self.get_skill(skill_id)?;
+    pub fn disable_skill(&self, skill_id: &str, req: RegistryActionRequest) -> Result<SkillSpec> {
+        self.disable_skill_with_context(&RequestContext::development_admin(), skill_id, req)
+    }
+
+    /// Disable a skill under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing record, or scope errors.
+    pub fn disable_skill_with_context(
+        &self,
+        context: &RequestContext,
+        skill_id: &str,
+        _req: RegistryActionRequest,
+    ) -> Result<SkillSpec> {
+        PermissionGuard::ensure(context, RuntimePermission::RegistryWrite)?;
+        let mut skill = self.get_skill_unscoped(skill_id)?;
+        assert_skill_scope(context, &skill)?;
         skill.status = SkillStatus::Disabled;
         skill.production_route_enabled = false;
+        skill.updated_by.clone_from(&context.actor);
+        skill.record_version = skill.record_version.saturating_add(1);
+        skill.request_id.clone_from(&context.request_id);
+        skill.correlation_id.clone_from(&context.correlation_id);
         skill.updated_at = Utc::now();
         self.skills
             .write()
@@ -396,6 +515,20 @@ impl SkillRegistryService {
     }
 }
 
+fn assert_skill_scope(context: &RequestContext, skill: &SkillSpec) -> Result<()> {
+    assert_runtime_scope(context, &skill.tenant_id, &skill.project_id)
+}
+
+impl SkillRegistryService {
+    fn get_skill_unscoped(&self, skill_id: &str) -> Result<SkillSpec> {
+        self.skills
+            .read()
+            .get(skill_id)
+            .cloned()
+            .ok_or_else(|| HarnessError::NotFound(format!("skill_id={skill_id}")))
+    }
+}
+
 fn validate_required(field: &str, value: &str) -> Result<()> {
     if value.trim().is_empty() {
         return Err(HarnessError::InvalidInput(format!("{field} is required")));
@@ -420,6 +553,7 @@ fn validate_license_policy(policy: &SkillLicensePolicy) -> Result<()> {
 #[cfg(test)]
 mod tests {
     use crate::error::HarnessError;
+    use crate::runtime_context::{RequestContext, RequestContextInput, RuntimeProfile};
 
     use super::{
         CreateSkillRequest, RegistryActionRequest, SkillCapability, SkillFixture,
@@ -459,6 +593,21 @@ mod tests {
         }
     }
 
+    fn context(actor: &str, roles: &[&str]) -> RequestContext {
+        RequestContext::from_input(
+            RequestContextInput {
+                tenant_id: Some("tenant-a".to_owned()),
+                project_id: Some("project-a".to_owned()),
+                actor: Some(actor.to_owned()),
+                roles: Some(roles.iter().map(|role| (*role).to_owned()).collect()),
+                request_id: Some(format!("req-{actor}")),
+                correlation_id: Some(format!("corr-{actor}")),
+            },
+            RuntimeProfile::Production,
+        )
+        .expect("context should parse")
+    }
+
     #[test]
     fn skill_registry_create_get_approve_disable() {
         let registry = SkillRegistryService::new();
@@ -512,6 +661,34 @@ mod tests {
         );
     }
 
+    #[test]
+    fn registry_approve_requires_registry_approve_permission() {
+        let registry = SkillRegistryService::new();
+        let engineer = context("engineer", &["engineer"]);
+        let reviewer = context("reviewer", &["reviewer"]);
+        registry
+            .create_skill_with_context(&engineer, create_request("needs-approval", "MIT"))
+            .expect("engineer can write draft");
+
+        let err = registry
+            .approve_skill_with_context(
+                &engineer,
+                "needs-approval",
+                RegistryActionRequest::default(),
+            )
+            .expect_err("engineer cannot approve registry records");
+        assert_eq!(err.http_status(), 403);
+
+        let approved = registry
+            .approve_skill_with_context(
+                &reviewer,
+                "needs-approval",
+                RegistryActionRequest::default(),
+            )
+            .expect("reviewer can approve registry records");
+        assert_eq!(approved.status, SkillStatus::Approved);
+    }
+
     #[test]
     fn permissive_commercial_licenses_can_be_approved() {
         for license in ["MIT", "Apache-2.0", "BSD-3-Clause"] {
diff --git a/04-backend/harness-core/src/storage_router.rs b/04-backend/harness-core/src/storage_router.rs
index 212dd56a..ae3dd406 100644
--- a/04-backend/harness-core/src/storage_router.rs
+++ b/04-backend/harness-core/src/storage_router.rs
@@ -214,6 +214,64 @@ pub struct ArtifactStorageBinding {
     pub file_reference: String,
 }
 
+/// Shared durable-store metadata carried by in-memory records today.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StoreRecordMetadata {
+    /// Record owner display name or user id.
+    pub owner: String,
+    /// Tenant id used for hard isolation.
+    pub tenant_id: String,
+    /// Project id used for hard isolation.
+    pub project_id: String,
+    /// Monotonic record version.
+    pub version: u32,
+    /// Request id that produced this record.
+    pub request_id: String,
+    /// Correlation id for multi-call workflows.
+    pub correlation_id: String,
+    /// Creation timestamp.
+    pub created_at: DateTime<Utc>,
+    /// Last update timestamp.
+    pub updated_at: DateTime<Utc>,
+}
+
+impl StoreRecordMetadata {
+    /// Build version-1 metadata for an in-memory record.
+    #[must_use]
+    pub fn new(
+        owner: String,
+        tenant_id: String,
+        project_id: String,
+        request_id: String,
+        correlation_id: String,
+    ) -> Self {
+        let now = Utc::now();
+        Self {
+            owner,
+            tenant_id,
+            project_id,
+            version: 1,
+            request_id,
+            correlation_id,
+            created_at: now,
+            updated_at: now,
+        }
+    }
+}
+
+impl Default for StoreRecordMetadata {
+    fn default() -> Self {
+        Self::new(
+            "dev-actor".to_owned(),
+            "dev-tenant".to_owned(),
+            "dev-project".to_owned(),
+            "dev-request".to_owned(),
+            "dev-correlation".to_owned(),
+        )
+    }
+}
+
 /// Artifact metadata persisted independently from binary content.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -240,6 +298,16 @@ pub struct ArtifactMetadata {
     pub size_bytes: u64,
     /// Owner display name or user id.
     pub owner: String,
+    /// Tenant id used for artifact isolation.
+    pub tenant_id: String,
+    /// Project id used for artifact isolation.
+    pub project_id: String,
+    /// Monotonic artifact metadata version.
+    pub version: u32,
+    /// Request id that produced this metadata.
+    pub request_id: String,
+    /// Correlation id for the generation workflow.
+    pub correlation_id: String,
     /// Source generation job id.
     pub source_job_id: Option<Uuid>,
     /// Generation job id that created this artifact.
@@ -250,6 +318,8 @@ pub struct ArtifactMetadata {
     pub audit_event_id: Option<Uuid>,
     /// Creation timestamp.
     pub created_at: DateTime<Utc>,
+    /// Last update timestamp.
+    pub updated_at: DateTime<Utc>,
 }
 
 /// One artifact version record.
@@ -347,6 +417,114 @@ pub trait ObjectStore: Send + Sync {
     fn stat_object(&self, key: &str) -> Result<ObjectStat>;
 }
 
+/// Durable artifact persistence capability.
+pub trait ArtifactStore<Record>: Send + Sync {
+    /// Put or replace one artifact record.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::InvalidInput`] when an adapter rejects the record.
+    fn put_artifact(&self, record: Record) -> Result<Record>;
+
+    /// Get one artifact record by id.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::NotFound`] when the artifact is unknown.
+    fn get_artifact(&self, id: Uuid) -> Result<Record>;
+
+    /// List artifact records with deterministic pagination.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::InvalidInput`] for an invalid cursor.
+    fn list_artifacts(
+        &self,
+        tenant_id: &str,
+        project_id: &str,
+        limit: Option<usize>,
+        cursor: Option<&str>,
+    ) -> Result<ListPage<Record>>;
+}
+
+/// Durable viewer-command persistence capability.
+pub trait ViewerCommandStore<Record>: Send + Sync {
+    /// Put or replace one viewer command.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::InvalidInput`] when an adapter rejects the record.
+    fn put_viewer_command(&self, record: Record) -> Result<Record>;
+
+    /// Get one viewer command by id.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::NotFound`] when the command is unknown.
+    fn get_viewer_command(&self, id: Uuid) -> Result<Record>;
+
+    /// List viewer commands with deterministic pagination.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::InvalidInput`] for an invalid cursor.
+    fn list_viewer_commands(
+        &self,
+        tenant_id: &str,
+        project_id: &str,
+        limit: Option<usize>,
+        cursor: Option<&str>,
+    ) -> Result<ListPage<Record>>;
+}
+
+/// Durable registry persistence capability shared by skills and MCP tools.
+pub trait RegistryStore<Record>: Send + Sync {
+    /// Put or replace one registry record.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::InvalidInput`] when an adapter rejects the record.
+    fn put_registry_record(&self, id: &str, record: Record) -> Result<Record>;
+
+    /// Get one registry record.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::NotFound`] when the record is unknown.
+    fn get_registry_record(&self, id: &str) -> Result<Record>;
+
+    /// List registry records with deterministic pagination.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::InvalidInput`] for an invalid cursor.
+    fn list_registry_records(
+        &self,
+        tenant_id: &str,
+        project_id: &str,
+        limit: Option<usize>,
+        cursor: Option<&str>,
+    ) -> Result<ListPage<Record>>;
+}
+
+/// Durable knowledge-source persistence capability.
+pub trait KnowledgeSourceStore<Record>: Send + Sync {
+    /// Put or replace one knowledge source.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::InvalidInput`] when an adapter rejects the record.
+    fn put_knowledge_source(&self, id: &str, record: Record) -> Result<Record>;
+
+    /// Get one knowledge source.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::NotFound`] when the source is unknown.
+    fn get_knowledge_source(&self, id: &str) -> Result<Record>;
+
+    /// List knowledge sources with deterministic pagination.
+    ///
+    /// # Errors
+    /// Returns [`HarnessError::InvalidInput`] for an invalid cursor.
+    fn list_knowledge_sources(
+        &self,
+        tenant_id: &str,
+        project_id: &str,
+        limit: Option<usize>,
+        cursor: Option<&str>,
+    ) -> Result<ListPage<Record>>;
+}
+
 /// In-memory `ObjectStore` preview adapter.
 #[derive(Debug, Clone, Default)]
 pub struct InMemoryObjectStore {
@@ -420,6 +598,8 @@ impl ObjectStore for InMemoryObjectStore {
 pub struct StorageTransactionRecord {
     /// Transaction id.
     pub id: Uuid,
+    /// Shared durable-store metadata.
+    pub store_metadata: StoreRecordMetadata,
     /// Transaction type.
     pub transaction_type: String,
     /// Transaction status.
@@ -494,8 +674,14 @@ impl TransactionStore for InMemoryTransactionStore {
         limit: Option<usize>,
         cursor: Option<&str>,
     ) -> Result<ListPage<StorageTransactionRecord>> {
-        let items: Vec<StorageTransactionRecord> =
+        let mut items: Vec<StorageTransactionRecord> =
             self.transactions.read().values().cloned().collect();
+        items.sort_by(|left, right| {
+            left.store_metadata
+                .created_at
+                .cmp(&right.store_metadata.created_at)
+                .then_with(|| left.id.as_bytes().cmp(right.id.as_bytes()))
+        });
         paginate(&items, limit, cursor)
     }
 }
@@ -506,6 +692,8 @@ impl TransactionStore for InMemoryTransactionStore {
 pub struct StorageEventRecord {
     /// Event id.
     pub id: Uuid,
+    /// Shared durable-store metadata.
+    pub store_metadata: StoreRecordMetadata,
     /// Event kind.
     pub event_type: String,
     /// Target type.
@@ -562,7 +750,13 @@ impl EventStore for InMemoryEventStore {
         limit: Option<usize>,
         cursor: Option<&str>,
     ) -> Result<ListPage<StorageEventRecord>> {
-        let items = self.events.read().clone();
+        let mut items = self.events.read().clone();
+        items.sort_by(|left, right| {
+            left.store_metadata
+                .created_at
+                .cmp(&right.store_metadata.created_at)
+                .then_with(|| left.id.as_bytes().cmp(right.id.as_bytes()))
+        });
         paginate(&items, limit, cursor)
     }
 }
@@ -622,7 +816,7 @@ mod tests {
         ArtifactMetadata, ArtifactRole, ArtifactStatus, ElementIdNamespace, EventStore,
         GeometryFormat, InMemoryEventStore, InMemoryObjectStore, InMemoryTransactionStore,
         ObjectPutRequest, ObjectStore, PropertyIndexFormat, StorageEventRecord,
-        StorageTransactionRecord, TransactionStore, ViewerAdapterHint,
+        StorageTransactionRecord, StoreRecordMetadata, TransactionStore, ViewerAdapterHint,
     };
 
     #[test]
@@ -655,9 +849,21 @@ mod tests {
         let transactions = InMemoryTransactionStore::new();
         let id = Uuid::new_v4();
         let now = Utc::now();
+        let older_metadata = StoreRecordMetadata {
+            created_at: now,
+            updated_at: now,
+            ..Default::default()
+        };
+        let newer_created_at = now + chrono::Duration::seconds(1);
+        let newer_metadata = StoreRecordMetadata {
+            created_at: newer_created_at,
+            updated_at: newer_created_at,
+            ..Default::default()
+        };
         transactions
             .put_transaction(StorageTransactionRecord {
                 id,
+                store_metadata: older_metadata.clone(),
                 transaction_type: "generation".to_owned(),
                 status: "draft".to_owned(),
                 payload: json!({ "mode": "cad_to_bim" }),
@@ -665,6 +871,18 @@ mod tests {
                 updated_at: now,
             })
             .expect("put transaction should work");
+        let newer_id = Uuid::new_v4();
+        transactions
+            .put_transaction(StorageTransactionRecord {
+                id: newer_id,
+                store_metadata: newer_metadata.clone(),
+                transaction_type: "generation".to_owned(),
+                status: "planned".to_owned(),
+                payload: json!({ "mode": "text_to_bim" }),
+                created_at: newer_metadata.created_at,
+                updated_at: newer_metadata.updated_at,
+            })
+            .expect("put second transaction should work");
         assert_eq!(
             transactions
                 .get_transaction(id)
@@ -678,13 +896,22 @@ mod tests {
                 .expect("list transactions")
                 .items
                 .len(),
-            1
+            2
+        );
+        assert_eq!(
+            transactions
+                .list_transactions(Some(10), None)
+                .expect("list transactions")
+                .items[0]
+                .id,
+            id
         );
 
         let events = InMemoryEventStore::new();
         events
             .append_event(StorageEventRecord {
                 id: Uuid::new_v4(),
+                store_metadata: newer_metadata,
                 event_type: "generation_stage_completed".to_owned(),
                 target_type: "generation_job".to_owned(),
                 target_id: id.to_string(),
@@ -692,13 +919,33 @@ mod tests {
                 created_at: now,
             })
             .expect("append event should work");
+        let first_event_id = Uuid::new_v4();
+        events
+            .append_event(StorageEventRecord {
+                id: first_event_id,
+                store_metadata: older_metadata,
+                event_type: "generation_job_created".to_owned(),
+                target_type: "generation_job".to_owned(),
+                target_id: id.to_string(),
+                payload: json!({ "stage": "queued" }),
+                created_at: now,
+            })
+            .expect("append older event should work");
         assert_eq!(
             events
                 .list_events(Some(10), None)
                 .expect("list events")
                 .items
                 .len(),
-            1
+            2
+        );
+        assert_eq!(
+            events
+                .list_events(Some(10), None)
+                .expect("list events")
+                .items[0]
+                .id,
+            first_event_id
         );
     }
 
@@ -716,11 +963,17 @@ mod tests {
             mime_type: "application/vnd.3dtiles+json".to_owned(),
             size_bytes: 128,
             owner: "tester".to_owned(),
+            tenant_id: "dev-tenant".to_owned(),
+            project_id: "dev-project".to_owned(),
+            version: 1,
+            request_id: "dev-request".to_owned(),
+            correlation_id: "dev-correlation".to_owned(),
             source_job_id: None,
             created_by_job_id: None,
             approval_status: ArtifactStatus::Preview,
             audit_event_id: None,
             created_at: Utc::now(),
+            updated_at: Utc::now(),
         };
         assert_eq!(metadata.geometry_format, Some(GeometryFormat::Tiles3d));
 
diff --git a/04-backend/harness-core/src/viewer_adapter.rs b/04-backend/harness-core/src/viewer_adapter.rs
index 6a42f4a9..70e46e7c 100644
--- a/04-backend/harness-core/src/viewer_adapter.rs
+++ b/04-backend/harness-core/src/viewer_adapter.rs
@@ -18,11 +18,11 @@ use crate::{
     module_generation::ModuleGenerationService,
     module_pagination::{ListPage, PageInfo, paginate},
     module_registry::normalize_module_id,
+    runtime_context::{PermissionGuard, RequestContext, RuntimePermission, assert_runtime_scope},
     storage_router::ViewerAdapterHint,
 };
 
 const DEFAULT_VIEWER_MODULE_ID: &str = "digital_twin";
-const DEFAULT_ACTOR: &str = "viewer";
 
 /// Viewer command supported by the `ViewerAdapter` contract.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
@@ -114,6 +114,10 @@ pub struct ViewerAdapterCommand {
     pub arguments: serde_json::Value,
     /// Current command status.
     pub status: ViewerCommandStatus,
+    /// Current request context for tenant/project isolation and audit.
+    pub context: RequestContext,
+    /// Monotonic in-memory command version.
+    pub version: u32,
     /// Audit event id that records this viewer command.
     pub audit_event_id: Option<Uuid>,
     /// Actor that acknowledged or executed the command.
@@ -215,6 +219,19 @@ impl ViewerCommandService {
     /// is unknown and [`HarnessError::InvalidInput`] when a vendor adapter is
     /// requested as a production route.
     pub fn create_command(&self, req: ViewerCommandCreateRequest) -> Result<ViewerAdapterCommand> {
+        self.create_command_with_context(&RequestContext::development_admin(), req)
+    }
+
+    /// Create one auditable viewer command under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, artifact/module lookup, or vendor-route errors.
+    pub fn create_command_with_context(
+        &self,
+        context: &RequestContext,
+        req: ViewerCommandCreateRequest,
+    ) -> Result<ViewerAdapterCommand> {
+        PermissionGuard::ensure(context, RuntimePermission::ViewerCommandCreate)?;
         let mut arguments = req.arguments.unwrap_or_else(|| json!({}));
         reject_vendor_production_route(req.adapter, &arguments)?;
         if req.adapter == ViewerAdapterHint::VendorOptrapid3d {
@@ -223,7 +240,7 @@ impl ViewerCommandService {
 
         let module_id = if let Some(artifact_id) = req.artifact_id {
             self.generation
-                .get_artifact(artifact_id)?
+                .get_artifact_with_context(context, artifact_id)?
                 .reference
                 .module_id
         } else if let Some(module_id) = req.module_id.as_deref() {
@@ -234,7 +251,7 @@ impl ViewerCommandService {
             DEFAULT_VIEWER_MODULE_ID.to_owned()
         };
 
-        let actor = req.actor.unwrap_or_else(|| DEFAULT_ACTOR.to_owned());
+        let actor = req.actor.unwrap_or_else(|| context.actor.clone());
         let now = Utc::now();
         let mut command = ViewerAdapterCommand {
             id: Uuid::new_v4(),
@@ -244,6 +261,8 @@ impl ViewerCommandService {
             element_ids: req.element_ids.unwrap_or_default(),
             arguments,
             status: ViewerCommandStatus::Queued,
+            context: context.clone(),
+            version: 1,
             audit_event_id: None,
             acknowledged_by: None,
             acknowledged_at: None,
@@ -261,7 +280,8 @@ impl ViewerCommandService {
                 "adapter": command.adapter,
                 "command": command.command,
                 "artifactId": command.artifact_id,
-                "candidateOnly": command.adapter == ViewerAdapterHint::VendorOptrapid3d
+                "candidateOnly": command.adapter == ViewerAdapterHint::VendorOptrapid3d,
+                "context": context.audit_json()
             }),
         });
         command.audit_event_id = Some(audit.id);
@@ -277,10 +297,27 @@ impl ViewerCommandService {
         &self,
         query: &ViewerCommandListQuery,
     ) -> Result<ListPage<ViewerAdapterCommand>> {
-        let items: Vec<ViewerAdapterCommand> = self
+        self.list_commands_with_context(&RequestContext::development_admin(), query)
+    }
+
+    /// List viewer commands visible to a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission or pagination errors.
+    pub fn list_commands_with_context(
+        &self,
+        context: &RequestContext,
+        query: &ViewerCommandListQuery,
+    ) -> Result<ListPage<ViewerAdapterCommand>> {
+        PermissionGuard::ensure(context, RuntimePermission::ArtifactRead)?;
+        let mut items: Vec<ViewerAdapterCommand> = self
             .commands
             .read()
             .values()
+            .filter(|command| {
+                command.context.tenant_id == context.tenant_id
+                    && command.context.project_id == context.project_id
+            })
             .filter(|command| query.status.is_none_or(|status| command.status == status))
             .filter(|command| {
                 query
@@ -295,6 +332,11 @@ impl ViewerCommandService {
             .filter(|command| query.command.is_none_or(|kind| command.command == kind))
             .cloned()
             .collect();
+        items.sort_by(|left, right| {
+            left.created_at
+                .cmp(&right.created_at)
+                .then_with(|| left.id.as_bytes().cmp(right.id.as_bytes()))
+        });
         paginate(&items, query.limit, query.cursor.as_deref())
     }
 
@@ -303,11 +345,27 @@ impl ViewerCommandService {
     /// # Errors
     /// Returns [`HarnessError::NotFound`] when the command id is unknown.
     pub fn get_command(&self, command_id: Uuid) -> Result<ViewerAdapterCommand> {
-        self.commands
+        self.get_command_with_context(&RequestContext::development_admin(), command_id)
+    }
+
+    /// Get one viewer command visible to a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing command, or scope errors.
+    pub fn get_command_with_context(
+        &self,
+        context: &RequestContext,
+        command_id: Uuid,
+    ) -> Result<ViewerAdapterCommand> {
+        PermissionGuard::ensure(context, RuntimePermission::ArtifactRead)?;
+        let command = self
+            .commands
             .read()
             .get(&command_id)
             .cloned()
-            .ok_or_else(|| HarnessError::NotFound(format!("viewer_command_id={command_id}")))
+            .ok_or_else(|| HarnessError::NotFound(format!("viewer_command_id={command_id}")))?;
+        assert_command_scope(context, &command)?;
+        Ok(command)
     }
 
     /// Execute or skip one viewer command.
@@ -320,6 +378,23 @@ impl ViewerCommandService {
         command_id: Uuid,
         req: ViewerCommandAckRequest,
     ) -> Result<ViewerAdapterCommand> {
+        self.ack_command_with_context(&RequestContext::development_admin(), command_id, req)
+    }
+
+    /// Execute or skip one viewer command under a runtime context.
+    ///
+    /// # Errors
+    /// Returns permission, missing command, scope, or invalid transition errors.
+    pub fn ack_command_with_context(
+        &self,
+        context: &RequestContext,
+        command_id: Uuid,
+        mut req: ViewerCommandAckRequest,
+    ) -> Result<ViewerAdapterCommand> {
+        PermissionGuard::ensure(context, RuntimePermission::ViewerCommandAck)?;
+        if req.actor.trim().is_empty() {
+            req.actor.clone_from(&context.actor);
+        }
         if req.status == ViewerCommandStatus::Queued {
             return Err(HarnessError::InvalidInput(
                 "ack status must be executed or skipped".to_owned(),
@@ -330,6 +405,7 @@ impl ViewerCommandService {
             let command = commands
                 .get_mut(&command_id)
                 .ok_or_else(|| HarnessError::NotFound(format!("viewer_command_id={command_id}")))?;
+            assert_command_scope(context, command)?;
             if matches!(
                 command.status,
                 ViewerCommandStatus::Executed | ViewerCommandStatus::Skipped
@@ -341,6 +417,8 @@ impl ViewerCommandService {
             }
             let now = Utc::now();
             command.status = req.status;
+            command.context = context.clone();
+            command.version = command.version.saturating_add(1);
             command.acknowledged_by = Some(req.actor.clone());
             command.acknowledged_at = Some(now);
             command.updated_at = now;
@@ -350,7 +428,11 @@ impl ViewerCommandService {
         };
         let module_id = command
             .artifact_id
-            .and_then(|artifact_id| self.generation.get_artifact(artifact_id).ok())
+            .and_then(|artifact_id| {
+                self.generation
+                    .get_artifact_with_context(context, artifact_id)
+                    .ok()
+            })
             .map_or_else(
                 || DEFAULT_VIEWER_MODULE_ID.to_owned(),
                 |artifact| artifact.reference.module_id,
@@ -365,13 +447,22 @@ impl ViewerCommandService {
             metadata: json!({
                 "status": command.status,
                 "comment": req.comment,
-                "result": req.result
+                "result": req.result,
+                "context": context.audit_json()
             }),
         });
         Ok(command)
     }
 }
 
+fn assert_command_scope(context: &RequestContext, command: &ViewerAdapterCommand) -> Result<()> {
+    assert_runtime_scope(
+        context,
+        &command.context.tenant_id,
+        &command.context.project_id,
+    )
+}
+
 fn reject_vendor_production_route(
     adapter: ViewerAdapterHint,
     arguments: &serde_json::Value,
@@ -421,6 +512,7 @@ mod tests {
             GenerationReviewRequest, ModuleGenerationService,
         },
         module_lifecycle::ModuleLifecycleService,
+        runtime_context::{RequestContext, RequestContextInput, RuntimeProfile},
         storage_router::ViewerAdapterHint,
     };
 
@@ -439,6 +531,21 @@ mod tests {
         )
     }
 
+    fn context(actor: &str, roles: &[&str]) -> RequestContext {
+        RequestContext::from_input(
+            RequestContextInput {
+                tenant_id: Some("tenant-a".to_owned()),
+                project_id: Some("project-a".to_owned()),
+                actor: Some(actor.to_owned()),
+                roles: Some(roles.iter().map(|role| (*role).to_owned()).collect()),
+                request_id: Some(format!("req-{actor}")),
+                correlation_id: Some(format!("corr-{actor}")),
+            },
+            RuntimeProfile::Production,
+        )
+        .expect("context should parse")
+    }
+
     fn generated_artifact_id(generation: &ModuleGenerationService) -> Uuid {
         let job = generation
             .create_job(GenerationInput {
@@ -491,6 +598,8 @@ mod tests {
             element_ids: vec!["architoken:wall:001".to_owned()],
             arguments: json!({ "color": "#ff6600" }),
             status: ViewerCommandStatus::Queued,
+            context: RequestContext::development_admin(),
+            version: 1,
             audit_event_id: Some(Uuid::new_v4()),
             acknowledged_by: None,
             acknowledged_at: None,
@@ -563,6 +672,59 @@ mod tests {
         assert!(result.is_err());
     }
 
+    #[test]
+    fn viewer_command_ack_requires_ack_permission() {
+        let audit = Arc::new(ModuleAuditService::new());
+        let (generation, _lifecycle) = generation_service(audit);
+        let service = ViewerCommandService::new(Arc::new(ModuleAuditService::new()), generation);
+        let engineer = context("engineer", &["engineer"]);
+        let admin = context("admin", &["admin"]);
+
+        let command = service
+            .create_command_with_context(
+                &engineer,
+                ViewerCommandCreateRequest {
+                    adapter: ViewerAdapterHint::ThreeJs,
+                    command: ViewerCommandKind::ZoomTo,
+                    module_id: Some("digital_twin".to_owned()),
+                    artifact_id: None,
+                    element_ids: None,
+                    arguments: None,
+                    actor: None,
+                },
+            )
+            .expect("engineer can create viewer commands");
+
+        let err = service
+            .ack_command_with_context(
+                &engineer,
+                command.id,
+                ViewerCommandAckRequest {
+                    actor: "engineer".to_owned(),
+                    status: ViewerCommandStatus::Executed,
+                    comment: None,
+                    result: None,
+                },
+            )
+            .expect_err("engineer cannot ack viewer commands");
+        assert_eq!(err.http_status(), 403);
+
+        let acked = service
+            .ack_command_with_context(
+                &admin,
+                command.id,
+                ViewerCommandAckRequest {
+                    actor: String::new(),
+                    status: ViewerCommandStatus::Skipped,
+                    comment: None,
+                    result: None,
+                },
+            )
+            .expect("admin can ack viewer commands");
+        assert_eq!(acked.status, ViewerCommandStatus::Skipped);
+        assert_eq!(acked.acknowledged_by.as_deref(), Some("admin"));
+    }
+
     #[test]
     fn ack_transitions_command_status() {
         let audit = Arc::new(ModuleAuditService::new());
diff --git a/04-backend/openapi.yaml b/04-backend/openapi.yaml
index ac1a2559..1492733c 100644
--- a/04-backend/openapi.yaml
+++ b/04-backend/openapi.yaml
@@ -79,6 +79,7 @@ paths:
             text/plain:
               schema: { type: string, example: "ok" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /readyz:
@@ -94,9 +95,17 @@ paths:
             text/plain:
               schema: { type: string, example: "ready" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /v1/runtime/capabilities:
+    parameters:
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: getRuntimeCapabilities
       summary: Discover runtime capabilities
@@ -131,10 +140,21 @@ paths:
                       providers: [memory]
                       persistsRealBytes: false
                       productionReady: false
+                    storeCapabilities:
+                      objectStore: true
+                      transactionStore: true
+                      eventStore: true
+                      registryStore: true
+                      artifactStore: true
+                      viewerCommandStore: true
+                      knowledgeSourceStore: true
+                      inMemoryOnly: true
+                      deterministicPagination: true
                     localImplementationMode: in_memory_preview
                     productionCaveats:
                       - No real commercial model APIs are connected.
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /v1/harness/invoke:
@@ -238,6 +258,7 @@ paths:
                       nextCursor: null
                       hasMore: false
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -286,6 +307,7 @@ paths:
                       createdAt: "2026-04-30T00:00:00Z"
                       updatedAt: "2026-04-30T00:00:00Z"
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -322,6 +344,7 @@ paths:
                       createdAt: "2026-04-30T00:00:00Z"
                       updatedAt: "2026-04-30T00:00:00Z"
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -364,6 +387,7 @@ paths:
                       createdAt: "2026-04-30T00:00:00Z"
                       updatedAt: "2026-04-30T00:10:00Z"
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -393,6 +417,7 @@ paths:
                     createdAt: "2026-04-30T00:00:00Z"
                     updatedAt: "2026-04-30T00:00:00Z"
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -419,6 +444,7 @@ paths:
                     contentType: text/plain
                     updatedAt: "2026-04-30T00:00:00Z"
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -452,6 +478,7 @@ paths:
                     contentType: text/plain
                     updatedAt: "2026-04-30T00:10:00Z"
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -498,6 +525,7 @@ paths:
                       createdAt: "2026-04-30T00:00:00Z"
                       updatedAt: "2026-04-30T00:10:00Z"
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -546,6 +574,7 @@ paths:
                       createdAt: "2026-04-30T00:10:00Z"
                       updatedAt: "2026-04-30T00:10:00Z"
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -582,6 +611,7 @@ paths:
                     permissions: [read]
                     expiresAt: "2026-05-01T00:00:00Z"
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -618,6 +648,7 @@ paths:
                       createdAt: "2026-04-30T00:00:00Z"
                       updatedAt: "2026-04-30T00:15:00Z"
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -659,6 +690,7 @@ paths:
                       nextCursor: null
                       hasMore: false
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -700,6 +732,7 @@ paths:
                     relatedArtifactIds: [cnc-package-v1]
                     approvals: []
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -731,6 +764,7 @@ paths:
                     relatedArtifactIds: [cnc-package-v1]
                     approvals: []
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -773,6 +807,7 @@ paths:
                     relatedArtifactIds: [cnc-package-v1]
                     approvals: []
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -820,6 +855,7 @@ paths:
                         comment: approved for release
                         decidedAt: "2026-04-30T00:40:00Z"
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -867,6 +903,7 @@ paths:
                         comment: CNC file needs revision
                         decidedAt: "2026-04-30T00:40:00Z"
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -919,11 +956,19 @@ paths:
                       limit: 50
                       cursor: null
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /v1/generation/jobs:
+    parameters:
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: listGenerationJobs
       summary: List AIGC generation jobs
@@ -984,6 +1029,7 @@ paths:
                       nextCursor: null
                       hasMore: false
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1082,6 +1128,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/GenerationJob" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1089,6 +1136,12 @@ paths:
   /v1/generation/jobs/{job_id}:
     parameters:
       - { $ref: "#/components/parameters/GenerationJobIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: getGenerationJob
       summary: Get one AIGC generation job
@@ -1100,6 +1153,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/GenerationJob" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1107,6 +1161,12 @@ paths:
   /v1/generation/jobs/{job_id}/plan:
     parameters:
       - { $ref: "#/components/parameters/GenerationJobIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     post:
       operationId: planGenerationJob
       summary: Run Planner stage for a generation job
@@ -1128,6 +1188,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/GenerationJob" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1135,6 +1196,12 @@ paths:
   /v1/generation/jobs/{job_id}/run:
     parameters:
       - { $ref: "#/components/parameters/GenerationJobIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     post:
       operationId: runGenerationJob
       summary: Run mock Generator, Evaluator, RuleChecker, and SchemaValidator stages
@@ -1157,6 +1224,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/GenerationJob" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1164,6 +1232,12 @@ paths:
   /v1/generation/jobs/{job_id}/review:
     parameters:
       - { $ref: "#/components/parameters/GenerationJobIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     post:
       operationId: reviewGenerationJob
       summary: Active-review a generated artifact before final approval
@@ -1186,6 +1260,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/GenerationJob" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1193,6 +1268,12 @@ paths:
   /v1/generation/jobs/{job_id}/approve:
     parameters:
       - { $ref: "#/components/parameters/GenerationJobIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     post:
       operationId: approveGenerationJob
       summary: Approve generated artifacts
@@ -1214,6 +1295,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/GenerationJob" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1221,6 +1303,12 @@ paths:
   /v1/generation/jobs/{job_id}/reject:
     parameters:
       - { $ref: "#/components/parameters/GenerationJobIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     post:
       operationId: rejectGenerationJob
       summary: Reject generated artifacts
@@ -1242,6 +1330,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/GenerationJob" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1249,6 +1338,12 @@ paths:
   /v1/generation/jobs/{job_id}/artifacts:
     parameters:
       - { $ref: "#/components/parameters/GenerationJobIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: listGenerationArtifacts
       summary: List artifacts produced or consumed by a generation job
@@ -1265,11 +1360,19 @@ paths:
                     jobId: "018f1d1d-7a7e-7f2b-a9d9-4c0f4c2f1001"
                     artifacts: []
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /v1/artifacts:
+    parameters:
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: listArtifacts
       summary: List standalone artifacts
@@ -1298,12 +1401,19 @@ paths:
                       nextCursor: null
                       hasMore: false
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /v1/artifacts/{artifact_id}:
     parameters:
       - { $ref: "#/components/parameters/ArtifactIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: getArtifact
       summary: Get one standalone artifact
@@ -1315,12 +1425,19 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/Artifact" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /v1/artifacts/{artifact_id}/versions:
     parameters:
       - { $ref: "#/components/parameters/ArtifactIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: listArtifactVersions
       summary: List one artifact's versions
@@ -1337,12 +1454,19 @@ paths:
                 empty:
                   value: []
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /v1/artifacts/{artifact_id}/metadata:
     parameters:
       - { $ref: "#/components/parameters/ArtifactIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: getArtifactMetadata
       summary: Get one artifact's metadata
@@ -1373,12 +1497,19 @@ paths:
                     auditEventId: null
                     createdAt: "2026-04-30T00:00:00Z"
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /v1/artifacts/{artifact_id}/storage-binding:
     parameters:
       - { $ref: "#/components/parameters/ArtifactIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: getArtifactStorageBinding
       summary: Get one artifact's storage binding
@@ -1399,10 +1530,18 @@ paths:
                     moduleFileId: null
                     fileReference: generation://files/018f1d1d-7a7e-7f2b-a9d9-4c0f4c2f1201
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /v1/viewer/commands:
+    parameters:
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: listViewerCommands
       summary: List auditable viewer commands
@@ -1421,6 +1560,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/ViewerCommandListResponse" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "500": { $ref: "#/components/responses/InternalServerError" }
     post:
@@ -1450,12 +1590,19 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/ViewerAdapterCommand" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /v1/viewer/commands/{command_id}:
     parameters:
       - { $ref: "#/components/parameters/ViewerCommandIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: getViewerCommand
       summary: Get one viewer command
@@ -1467,12 +1614,19 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/ViewerAdapterCommand" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /v1/viewer/commands/{command_id}/ack:
     parameters:
       - { $ref: "#/components/parameters/ViewerCommandIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     post:
       operationId: ackViewerCommand
       summary: Execute or skip one viewer command
@@ -1504,10 +1658,18 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/ViewerAdapterCommand" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /v1/skills:
+    parameters:
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: listSkills
       summary: List AI skill registry entries
@@ -1562,6 +1724,7 @@ paths:
                       nextCursor: null
                       hasMore: false
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1605,6 +1768,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/SkillSpec" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1612,6 +1776,12 @@ paths:
   /v1/skills/{skill_id}:
     parameters:
       - { $ref: "#/components/parameters/SkillIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: getSkill
       summary: Get one skill registry entry
@@ -1623,6 +1793,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/SkillSpec" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1650,6 +1821,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/SkillSpec" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1657,6 +1829,12 @@ paths:
   /v1/skills/{skill_id}/approve:
     parameters:
       - { $ref: "#/components/parameters/SkillIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     post:
       operationId: approveSkill
       summary: Approve a commercial-safe skill for production routes
@@ -1678,6 +1856,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/SkillSpec" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1685,6 +1864,12 @@ paths:
   /v1/skills/{skill_id}/disable:
     parameters:
       - { $ref: "#/components/parameters/SkillIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     post:
       operationId: disableSkill
       summary: Disable a skill route
@@ -1706,11 +1891,19 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/SkillSpec" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /v1/mcp-tools:
+    parameters:
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: listMcpTools
       summary: List MCP tool registry entries
@@ -1759,6 +1952,7 @@ paths:
                       nextCursor: null
                       hasMore: false
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1800,6 +1994,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/McpToolSpec" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1807,6 +2002,12 @@ paths:
   /v1/mcp-tools/{tool_id}:
     parameters:
       - { $ref: "#/components/parameters/McpToolIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: getMcpTool
       summary: Get one MCP tool registry entry
@@ -1818,6 +2019,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/McpToolSpec" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1842,6 +2044,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/McpToolSpec" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1849,6 +2052,12 @@ paths:
   /v1/mcp-tools/{tool_id}/approve:
     parameters:
       - { $ref: "#/components/parameters/McpToolIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     post:
       operationId: approveMcpTool
       summary: Approve an MCP tool contract
@@ -1870,6 +2079,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/McpToolSpec" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -1877,6 +2087,12 @@ paths:
   /v1/mcp-tools/{tool_id}/disable:
     parameters:
       - { $ref: "#/components/parameters/McpToolIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     post:
       operationId: disableMcpTool
       summary: Disable an MCP tool contract
@@ -1898,11 +2114,19 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/McpToolSpec" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
 
   /v1/knowledge-sources:
+    parameters:
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: listKnowledgeSources
       summary: List knowledge source registry entries
@@ -1958,6 +2182,7 @@ paths:
                       nextCursor: null
                       hasMore: false
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -2005,6 +2230,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/KnowledgeSource" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -2012,6 +2238,12 @@ paths:
   /v1/knowledge-sources/{source_id}:
     parameters:
       - { $ref: "#/components/parameters/KnowledgeSourceIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     get:
       operationId: getKnowledgeSource
       summary: Get one knowledge source registry entry
@@ -2023,6 +2255,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/KnowledgeSource" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -2046,6 +2279,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/KnowledgeSource" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -2053,6 +2287,12 @@ paths:
   /v1/knowledge-sources/{source_id}/ingest:
     parameters:
       - { $ref: "#/components/parameters/KnowledgeSourceIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     post:
       operationId: ingestKnowledgeSource
       summary: Start a mock knowledge ingest job
@@ -2075,6 +2315,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/KnowledgeIngestionJob" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -2082,6 +2323,12 @@ paths:
   /v1/knowledge-sources/{source_id}/approve:
     parameters:
       - { $ref: "#/components/parameters/KnowledgeSourceIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     post:
       operationId: approveKnowledgeSource
       summary: Approve a knowledge source
@@ -2103,6 +2350,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/KnowledgeSource" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -2110,6 +2358,12 @@ paths:
   /v1/knowledge-sources/{source_id}/disable:
     parameters:
       - { $ref: "#/components/parameters/KnowledgeSourceIdParam" }
+      - { $ref: "#/components/parameters/TenantIdHeader" }
+      - { $ref: "#/components/parameters/ProjectIdHeader" }
+      - { $ref: "#/components/parameters/ActorHeader" }
+      - { $ref: "#/components/parameters/RolesHeader" }
+      - { $ref: "#/components/parameters/RequestIdHeader" }
+      - { $ref: "#/components/parameters/CorrelationIdHeader" }
     post:
       operationId: disableKnowledgeSource
       summary: Disable a knowledge source
@@ -2131,6 +2385,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/KnowledgeSource" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
         "409": { $ref: "#/components/responses/Conflict" }
         "500": { $ref: "#/components/responses/InternalServerError" }
@@ -2153,6 +2408,7 @@ paths:
               schema: { $ref: "#/components/schemas/AgentResponse" }
         "401": { $ref: "#/components/responses/Unauthorized" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "502": { $ref: "#/components/responses/UpstreamError" }
 
   /v1/phases:
@@ -2173,6 +2429,7 @@ paths:
                     type: array
                     items: { $ref: "#/components/schemas/BusinessPhase" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
 
   /v1/projects:
     get:
@@ -2195,6 +2452,7 @@ paths:
                     items: { $ref: "#/components/schemas/Project" }
                   total: { type: integer, minimum: 0 }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "401": { $ref: "#/components/responses/Unauthorized" }
     post:
       operationId: createProject
@@ -2212,6 +2470,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/Project" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "401": { $ref: "#/components/responses/Unauthorized" }
 
   /v1/projects/{id}:
@@ -2228,6 +2487,7 @@ paths:
             application/json:
               schema: { $ref: "#/components/schemas/Project" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
 
   /v1/projects/{id}/bim:
@@ -2259,6 +2519,7 @@ paths:
                   upload_id: { type: string, format: uuid }
                   status: { type: string, enum: [queued] }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
 
   /v1/projects/{id}/boq:
@@ -2277,6 +2538,7 @@ paths:
                 type: array
                 items: { $ref: "#/components/schemas/BoqItem" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
 
   /v1/projects/{id}/compliance:
@@ -2295,6 +2557,7 @@ paths:
                 type: array
                 items: { $ref: "#/components/schemas/ComplianceFinding" }
         "400": { $ref: "#/components/responses/ValidationError" }
+        "403": { $ref: "#/components/responses/Forbidden" }
         "404": { $ref: "#/components/responses/NotFound" }
 
 components:
@@ -2362,6 +2625,48 @@ components:
       description: Opaque pagination cursor. Current preview uses numeric offsets.
       schema: { type: string }
       example: "50"
+    TenantIdHeader:
+      in: header
+      name: X-Tenant-Id
+      required: false
+      description: Runtime tenant id. Required in production-like profiles; development may use a weak fallback.
+      schema: { type: string }
+      example: tenant-demo
+    ProjectIdHeader:
+      in: header
+      name: X-Project-Id
+      required: false
+      description: Runtime project id. Required in production-like profiles; development may use a weak fallback.
+      schema: { type: string }
+      example: project-demo
+    ActorHeader:
+      in: header
+      name: X-Actor
+      required: false
+      description: Runtime actor id used for audit payloads.
+      schema: { type: string }
+      example: engineer@example.com
+    RolesHeader:
+      in: header
+      name: X-Roles
+      required: false
+      description: Comma-separated preview roles used by the in-memory RBAC guard.
+      schema: { type: string }
+      example: engineer,reviewer
+    RequestIdHeader:
+      in: header
+      name: X-Request-Id
+      required: false
+      description: Request id copied into runtime metadata and audit payloads.
+      schema: { type: string }
+      example: req-20260430-001
+    CorrelationIdHeader:
+      in: header
+      name: X-Correlation-Id
+      required: false
+      description: Correlation id copied into runtime metadata and audit payloads.
+      schema: { type: string }
+      example: corr-phase6-demo
     FileParentIdQuery:
       in: query
       name: parentId
@@ -2565,6 +2870,19 @@ components:
       content:
         application/json:
           schema: { $ref: "#/components/schemas/ErrorResponse" }
+    Forbidden:
+      description: Permission denied or tenant/project isolation guard rejected the request
+      content:
+        application/json:
+          schema:
+            oneOf:
+              - $ref: "#/components/schemas/ErrorResponse"
+              - $ref: "#/components/schemas/PermissionDecision"
+          examples:
+            permissionDenied:
+              value:
+                error: "sandbox denied: {\"allowed\":false,\"permission\":\"generation:create\",\"actor\":\"auditor@example.com\",\"tenantId\":\"tenant-demo\",\"projectId\":\"project-demo\"}"
+                code: 403
     ValidationError:
       description: Request failed validation
       content:
@@ -2607,6 +2925,72 @@ components:
         error: "not found: file_id=018f1d1d-7a7e-7f2b-a9d9-4c0f4c2f0001"
         code: 404
 
+    RuntimeRole:
+      type: string
+      enum: [admin, engineer, reviewer, auditor]
+
+    RuntimePermission:
+      type: string
+      enum:
+        - artifact:read
+        - artifact:write
+        - generation:create
+        - generation:run
+        - generation:review
+        - generation:approve
+        - registry:read
+        - registry:write
+        - registry:approve
+        - viewer:command:create
+        - viewer:command:ack
+        - knowledge:ingest
+
+    RequestContext:
+      type: object
+      required: [tenantId, projectId, actor, roles, requestId, correlationId]
+      properties:
+        tenantId: { type: string }
+        projectId: { type: string }
+        actor: { type: string }
+        roles:
+          type: array
+          items: { $ref: "#/components/schemas/RuntimeRole" }
+        requestId: { type: string }
+        correlationId: { type: string }
+      example:
+        tenantId: tenant-demo
+        projectId: project-demo
+        actor: engineer@example.com
+        roles: [engineer]
+        requestId: req-20260430-001
+        correlationId: corr-phase6-demo
+
+    PermissionDecision:
+      type: object
+      required: [allowed, permission, actor, roles, tenantId, projectId, requestId, correlationId]
+      properties:
+        allowed: { type: boolean }
+        permission: { $ref: "#/components/schemas/RuntimePermission" }
+        actor: { type: string }
+        roles:
+          type: array
+          items: { $ref: "#/components/schemas/RuntimeRole" }
+        tenantId: { type: string }
+        projectId: { type: string }
+        requestId: { type: string }
+        correlationId: { type: string }
+        reason: { type: [string, "null"] }
+      example:
+        allowed: false
+        permission: generation:create
+        actor: auditor@example.com
+        roles: [auditor]
+        tenantId: tenant-demo
+        projectId: project-demo
+        requestId: req-20260430-001
+        correlationId: corr-phase6-demo
+        reason: permission generation:create denied for actor auditor@example.com
+
     PageInfo:
       type: object
       required: [limit, hasMore]
@@ -2927,6 +3311,7 @@ components:
         - viewer
         - registry
         - storage
+        - storeCapabilities
         - localImplementationMode
         - productionCaveats
       properties:
@@ -2941,6 +3326,8 @@ components:
           $ref: "#/components/schemas/RuntimeRegistryCapabilities"
         storage:
           $ref: "#/components/schemas/RuntimeStorageCapabilities"
+        storeCapabilities:
+          $ref: "#/components/schemas/RuntimeStoreCapabilities"
         localImplementationMode:
           type: string
           enum: [in_memory_preview]
@@ -2967,6 +3354,16 @@ components:
           providers: [memory]
           persistsRealBytes: false
           productionReady: false
+        storeCapabilities:
+          objectStore: true
+          transactionStore: true
+          eventStore: true
+          registryStore: true
+          artifactStore: true
+          viewerCommandStore: true
+          knowledgeSourceStore: true
+          inMemoryOnly: true
+          deterministicPagination: true
         localImplementationMode: in_memory_preview
         productionCaveats:
           - No real commercial model APIs are connected.
@@ -2997,6 +3394,29 @@ components:
         productionReady:
           type: boolean
 
+    RuntimeStoreCapabilities:
+      type: object
+      required:
+        - objectStore
+        - transactionStore
+        - eventStore
+        - registryStore
+        - artifactStore
+        - viewerCommandStore
+        - knowledgeSourceStore
+        - inMemoryOnly
+        - deterministicPagination
+      properties:
+        objectStore: { type: boolean }
+        transactionStore: { type: boolean }
+        eventStore: { type: boolean }
+        registryStore: { type: boolean }
+        artifactStore: { type: boolean }
+        viewerCommandStore: { type: boolean }
+        knowledgeSourceStore: { type: boolean }
+        inMemoryOnly: { type: boolean }
+        deterministicPagination: { type: boolean }
+
     RuntimeViewerCapabilities:
       type: object
       required: [adapterHints, commandKinds, candidateOnlyAdapterHints]
@@ -3185,6 +3605,11 @@ components:
           additionalProperties: true
         status:
           $ref: "#/components/schemas/ViewerCommandStatus"
+        context:
+          $ref: "#/components/schemas/RequestContext"
+        version:
+          type: integer
+          minimum: 1
         auditEventId:
           type: [string, "null"]
           format: uuid
@@ -3208,6 +3633,14 @@ components:
         arguments:
           color: "#ff6600"
         status: queued
+        context:
+          tenantId: tenant-demo
+          projectId: project-demo
+          actor: viewer-dev
+          roles: [engineer]
+          requestId: req-20260430-001
+          correlationId: corr-phase6-demo
+        version: 1
         auditEventId: "018f1d1d-7a7e-7f2b-a9d9-4c0f4c2f0301"
         acknowledgedBy: null
         acknowledgedAt: null
@@ -3363,6 +3796,17 @@ components:
           minimum: 0
         owner:
           type: string
+        tenantId:
+          type: string
+        projectId:
+          type: string
+        version:
+          type: integer
+          minimum: 1
+        requestId:
+          type: string
+        correlationId:
+          type: string
         sourceJobId:
           type: [string, "null"]
           format: uuid
@@ -3377,6 +3821,9 @@ components:
         createdAt:
           type: string
           format: date-time
+        updatedAt:
+          type: string
+          format: date-time
 
     ArtifactVersion:
       type: object
@@ -3725,6 +4172,13 @@ components:
         id: { type: string }
         name: { type: string }
         owner: { type: string }
+        tenantId: { type: string }
+        projectId: { type: string }
+        createdBy: { type: string }
+        updatedBy: { type: string }
+        recordVersion: { type: integer, minimum: 1 }
+        requestId: { type: string }
+        correlationId: { type: string }
         version: { $ref: "#/components/schemas/SkillVersion" }
         inputSchemaRef: { type: string }
         outputSchemaRef: { type: string }
@@ -3837,6 +4291,13 @@ components:
         id: { type: string }
         name: { type: string }
         owner: { type: string }
+        tenantId: { type: string }
+        projectId: { type: string }
+        createdBy: { type: string }
+        updatedBy: { type: string }
+        recordVersion: { type: integer, minimum: 1 }
+        requestId: { type: string }
+        correlationId: { type: string }
         version: { type: string }
         capability: { $ref: "#/components/schemas/McpToolCapability" }
         permissionScope: { $ref: "#/components/schemas/McpPermissionScope" }
@@ -3970,6 +4431,13 @@ components:
           type: array
           items: { type: string }
         owner: { type: string }
+        tenantId: { type: string }
+        projectId: { type: string }
+        createdBy: { type: string }
+        updatedBy: { type: string }
+        recordVersion: { type: integer, minimum: 1 }
+        requestId: { type: string }
+        correlationId: { type: string }
         refreshPolicy: { type: string }
         permissionPolicy: { type: string }
         auditPolicy: { type: string }
@@ -4036,6 +4504,11 @@ components:
       properties:
         id: { type: string, format: uuid }
         sourceId: { type: string }
+        tenantId: { type: string }
+        projectId: { type: string }
+        actor: { type: string }
+        requestId: { type: string }
+        correlationId: { type: string }
         status: { type: string }
         summary: { type: string }
         createdAt: { type: string, format: date-time }
@@ -4185,6 +4658,11 @@ components:
           format: uuid
         actor:
           type: string
+        context:
+          $ref: "#/components/schemas/RequestContext"
+        version:
+          type: integer
+          minimum: 1
         createdAt:
           type: string
           format: date-time
@@ -4223,6 +4701,14 @@ components:
         artifacts: []
         lifecycleTransactionId: null
         actor: dev
+        context:
+          tenantId: tenant-demo
+          projectId: project-demo
+          actor: dev
+          roles: [admin]
+          requestId: req-20260430-001
+          correlationId: corr-phase6-demo
+        version: 1
         createdAt: "2026-04-30T00:00:00Z"
         updatedAt: "2026-04-30T00:00:00Z"
 
diff --git a/04-backend/scripts/smoke-all.sh b/04-backend/scripts/smoke-all.sh
index 976d15ca..35b0cc68 100755
--- a/04-backend/scripts/smoke-all.sh
+++ b/04-backend/scripts/smoke-all.sh
@@ -2,18 +2,12 @@
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-ARCHITOKEN_API_BASE_URL="${ARCHITOKEN_API_BASE_URL:-${BASE_URL:-http://localhost:8080}}"
+source "${SCRIPT_DIR}/smoke-context.sh"
+ARCHITOKEN_API_BASE_URL="${BASE_URL}"
 export ARCHITOKEN_API_BASE_URL
 
 trap 'printf "smoke-all failed at line %s against %s\n" "${LINENO}" "${ARCHITOKEN_API_BASE_URL}" >&2' ERR
 
-need_jq() {
-  if ! command -v jq >/dev/null 2>&1; then
-    printf 'jq is required for ArchIToken smoke scripts. Install jq and retry.\n' >&2
-    exit 1
-  fi
-}
-
 need_jq
 
 "${SCRIPT_DIR}/smoke-health.sh"
@@ -21,5 +15,6 @@ need_jq
 "${SCRIPT_DIR}/smoke-artifacts.sh"
 "${SCRIPT_DIR}/smoke-registries.sh"
 "${SCRIPT_DIR}/smoke-viewer-commands.sh"
+"${SCRIPT_DIR}/smoke-rbac.sh"
 
-printf 'all ArchIToken Phase 5 API smoke checks passed for %s\n' "${ARCHITOKEN_API_BASE_URL}"
+printf 'all ArchIToken Phase 6 API smoke checks passed for %s tenant=%s project=%s\n' "${ARCHITOKEN_API_BASE_URL}" "${ARCHITOKEN_TENANT_ID}" "${ARCHITOKEN_PROJECT_ID}"
diff --git a/04-backend/scripts/smoke-artifacts.sh b/04-backend/scripts/smoke-artifacts.sh
index 1b4669e1..6375b639 100755
--- a/04-backend/scripts/smoke-artifacts.sh
+++ b/04-backend/scripts/smoke-artifacts.sh
@@ -1,38 +1,32 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-BASE_URL="${ARCHITOKEN_API_BASE_URL:-${BASE_URL:-http://localhost:8080}}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/smoke-context.sh"
 trap 'printf "smoke-artifacts failed at line %s against %s\n" "${LINENO}" "${BASE_URL}" >&2' ERR
 
-need_jq() {
-  if ! command -v jq >/dev/null 2>&1; then
-    printf 'jq is required for ArchIToken smoke scripts. Install jq and retry.\n' >&2
-    exit 1
-  fi
-}
-
 need_jq
 
 if [[ ! -s /tmp/architoken-smoke-artifact-id ]]; then
-  "$(dirname "$0")/smoke-generation.sh"
+  "${SCRIPT_DIR}/smoke-generation.sh"
 fi
 
 artifact_id="$(cat /tmp/architoken-smoke-artifact-id)"
 job_id="$(cat /tmp/architoken-smoke-generation-job-id)"
 
-list="$(curl -fsS "${BASE_URL}/v1/artifacts?source_job_id=${job_id}&status=approved")"
+list="$(get_json "/v1/artifacts?source_job_id=${job_id}&status=approved")"
 printf '%s\n' "${list}" | jq -e --arg artifact_id "${artifact_id}" '.artifacts[] | select(.id == $artifact_id and .status == "approved")' >/dev/null
 
-artifact="$(curl -fsS "${BASE_URL}/v1/artifacts/${artifact_id}")"
+artifact="$(get_json "/v1/artifacts/${artifact_id}")"
 printf '%s\n' "${artifact}" | jq -e '.reference.artifactId == .id' >/dev/null
 
-versions="$(curl -fsS "${BASE_URL}/v1/artifacts/${artifact_id}/versions")"
+versions="$(get_json "/v1/artifacts/${artifact_id}/versions")"
 printf '%s\n' "${versions}" | jq -e 'length >= 1 and .[0].status == "approved"' >/dev/null
 
-metadata="$(curl -fsS "${BASE_URL}/v1/artifacts/${artifact_id}/metadata")"
-printf '%s\n' "${metadata}" | jq -e '.approvalStatus == "approved" and .sourceJobId != null' >/dev/null
+metadata="$(get_json "/v1/artifacts/${artifact_id}/metadata")"
+printf '%s\n' "${metadata}" | jq -e --arg tenant "${ARCHITOKEN_TENANT_ID}" --arg project "${ARCHITOKEN_PROJECT_ID}" '.approvalStatus == "approved" and .sourceJobId != null and .tenantId == $tenant and .projectId == $project' >/dev/null
 
-binding="$(curl -fsS "${BASE_URL}/v1/artifacts/${artifact_id}/storage-binding")"
+binding="$(get_json "/v1/artifacts/${artifact_id}/storage-binding")"
 printf '%s\n' "${binding}" | jq -e '.provider == "memory" and (.objectUri | startswith("memory://"))' >/dev/null
 
 printf 'artifact smoke passed, artifact_id=%s\n' "${artifact_id}"
diff --git a/04-backend/scripts/smoke-context.sh b/04-backend/scripts/smoke-context.sh
new file mode 100755
index 00000000..702fe79f
--- /dev/null
+++ b/04-backend/scripts/smoke-context.sh
@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+BASE_URL="${ARCHITOKEN_API_BASE_URL:-${BASE_URL:-http://localhost:8080}}"
+ARCHITOKEN_TENANT_ID="${ARCHITOKEN_TENANT_ID:-smoke-tenant}"
+ARCHITOKEN_PROJECT_ID="${ARCHITOKEN_PROJECT_ID:-smoke-project}"
+ARCHITOKEN_ACTOR="${ARCHITOKEN_ACTOR:-smoke}"
+ARCHITOKEN_ROLES="${ARCHITOKEN_ROLES:-admin}"
+
+export BASE_URL ARCHITOKEN_TENANT_ID ARCHITOKEN_PROJECT_ID ARCHITOKEN_ACTOR ARCHITOKEN_ROLES
+
+context_headers=(
+  -H "X-Tenant-Id: ${ARCHITOKEN_TENANT_ID}"
+  -H "X-Project-Id: ${ARCHITOKEN_PROJECT_ID}"
+  -H "X-Actor: ${ARCHITOKEN_ACTOR}"
+  -H "X-Roles: ${ARCHITOKEN_ROLES}"
+  -H "X-Request-Id: smoke-${ARCHITOKEN_ACTOR}"
+  -H "X-Correlation-Id: smoke-phase6"
+)
+
+json_headers=(
+  -H 'Content-Type: application/json'
+  -H 'Accept: application/json'
+)
+
+need_jq() {
+  if ! command -v jq >/dev/null 2>&1; then
+    printf 'jq is required for ArchIToken smoke scripts. Install jq and retry.\n' >&2
+    exit 1
+  fi
+}
+
+get_json() {
+  local path="$1"
+  curl -fsS "${BASE_URL}${path}" "${context_headers[@]}" -H 'Accept: application/json'
+}
+
+post_json() {
+  local path="$1"
+  local body="$2"
+  curl -fsS -X POST "${BASE_URL}${path}" \
+    "${context_headers[@]}" \
+    "${json_headers[@]}" \
+    --data "${body}"
+}
diff --git a/04-backend/scripts/smoke-generation.sh b/04-backend/scripts/smoke-generation.sh
index 821a29a3..707027b1 100755
--- a/04-backend/scripts/smoke-generation.sh
+++ b/04-backend/scripts/smoke-generation.sh
@@ -1,25 +1,10 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-BASE_URL="${ARCHITOKEN_API_BASE_URL:-${BASE_URL:-http://localhost:8080}}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/smoke-context.sh"
 trap 'printf "smoke-generation failed at line %s against %s\n" "${LINENO}" "${BASE_URL}" >&2' ERR
 
-need_jq() {
-  if ! command -v jq >/dev/null 2>&1; then
-    printf 'jq is required for ArchIToken smoke scripts. Install jq and retry.\n' >&2
-    exit 1
-  fi
-}
-
-post_json() {
-  local path="$1"
-  local body="$2"
-  curl -fsS -X POST "${BASE_URL}${path}" \
-    -H 'Content-Type: application/json' \
-    -H 'Accept: application/json' \
-    --data "${body}"
-}
-
 need_jq
 
 job="$(
@@ -31,6 +16,7 @@ job="$(
   }'
 )"
 job_id="$(printf '%s\n' "${job}" | jq -r '.id')"
+printf '%s\n' "${job}" | jq -e --arg tenant "${ARCHITOKEN_TENANT_ID}" --arg project "${ARCHITOKEN_PROJECT_ID}" '.context.tenantId == $tenant and .context.projectId == $project' >/dev/null
 
 planned="$(post_json "/v1/generation/jobs/${job_id}/plan" '{"actor":"smoke-generation","comment":"smoke plan"}')"
 printf '%s\n' "${planned}" | jq -e '.status == "planned"' >/dev/null
@@ -51,7 +37,7 @@ approved="$(post_json "/v1/generation/jobs/${job_id}/approve" '{"actor":"smoke-g
 printf '%s\n' "${approved}" | jq -e '.status == "approved"' >/dev/null
 printf '%s\n' "${approved}" | jq -e '[.artifacts[] | select(.status == "approved")] | length >= 3' >/dev/null
 
-artifacts="$(curl -fsS "${BASE_URL}/v1/generation/jobs/${job_id}/artifacts")"
+artifacts="$(get_json "/v1/generation/jobs/${job_id}/artifacts")"
 printf '%s\n' "${artifacts}" | jq -e '.artifacts | length >= 3' >/dev/null
 
 printf '%s\n' "${job_id}" >/tmp/architoken-smoke-generation-job-id
diff --git a/04-backend/scripts/smoke-health.sh b/04-backend/scripts/smoke-health.sh
index e049a5a1..a40dc527 100755
--- a/04-backend/scripts/smoke-health.sh
+++ b/04-backend/scripts/smoke-health.sh
@@ -1,23 +1,18 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-BASE_URL="${ARCHITOKEN_API_BASE_URL:-${BASE_URL:-http://localhost:8080}}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/smoke-context.sh"
 trap 'printf "smoke-health failed at line %s against %s\n" "${LINENO}" "${BASE_URL}" >&2' ERR
 
-need_jq() {
-  if ! command -v jq >/dev/null 2>&1; then
-    printf 'jq is required for ArchIToken smoke scripts. Install jq and retry.\n' >&2
-    exit 1
-  fi
-}
-
 need_jq
 
 health="$(curl -fsS "${BASE_URL}/healthz")"
 ready="$(curl -fsS "${BASE_URL}/readyz")"
-capabilities="$(curl -fsS "${BASE_URL}/v1/runtime/capabilities")"
+capabilities="$(get_json '/v1/runtime/capabilities')"
 
 test "${health}" = "ok"
 test "${ready}" = "ready"
 printf '%s\n' "${capabilities}" | jq -e '.localImplementationMode == "in_memory_preview"' >/dev/null
+printf '%s\n' "${capabilities}" | jq -e '.storeCapabilities.artifactStore == true and .storeCapabilities.deterministicPagination == true' >/dev/null
 printf 'health smoke passed for %s\n' "${BASE_URL}"
diff --git a/04-backend/scripts/smoke-rbac.sh b/04-backend/scripts/smoke-rbac.sh
new file mode 100755
index 00000000..0634bd49
--- /dev/null
+++ b/04-backend/scripts/smoke-rbac.sh
@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/smoke-context.sh"
+trap 'printf "smoke-rbac failed at line %s against %s\n" "${LINENO}" "${BASE_URL}" >&2' ERR
+
+need_jq
+
+context_args_for() {
+  local tenant="$1"
+  local project="$2"
+  local actor="$3"
+  local roles="$4"
+  printf '%s\n' \
+    "-H" "X-Tenant-Id: ${tenant}" \
+    "-H" "X-Project-Id: ${project}" \
+    "-H" "X-Actor: ${actor}" \
+    "-H" "X-Roles: ${roles}" \
+    "-H" "X-Request-Id: smoke-rbac-${actor}" \
+    "-H" "X-Correlation-Id: smoke-rbac"
+}
+
+post_as() {
+  local tenant="$1"
+  local project="$2"
+  local actor="$3"
+  local roles="$4"
+  local path="$5"
+  local body="$6"
+  mapfile -t args < <(context_args_for "${tenant}" "${project}" "${actor}" "${roles}")
+  curl -fsS -X POST "${BASE_URL}${path}" "${args[@]}" "${json_headers[@]}" --data "${body}"
+}
+
+get_as() {
+  local tenant="$1"
+  local project="$2"
+  local actor="$3"
+  local roles="$4"
+  local path="$5"
+  mapfile -t args < <(context_args_for "${tenant}" "${project}" "${actor}" "${roles}")
+  curl -fsS "${BASE_URL}${path}" "${args[@]}" -H 'Accept: application/json'
+}
+
+status_post_as() {
+  local tenant="$1"
+  local project="$2"
+  local actor="$3"
+  local roles="$4"
+  local path="$5"
+  local body="$6"
+  local output="$7"
+  mapfile -t args < <(context_args_for "${tenant}" "${project}" "${actor}" "${roles}")
+  curl -sS -o "${output}" -w '%{http_code}' -X POST "${BASE_URL}${path}" \
+    "${args[@]}" \
+    "${json_headers[@]}" \
+    --data "${body}"
+}
+
+tenant_a="${ARCHITOKEN_TENANT_ID}-rbac-a"
+tenant_b="${ARCHITOKEN_TENANT_ID}-rbac-b"
+project="${ARCHITOKEN_PROJECT_ID}-rbac"
+
+engineer_job="$(
+  post_as "${tenant_a}" "${project}" "rbac-engineer" "engineer" '/v1/generation/jobs' '{
+    "moduleId": "digital_twin",
+    "mode": "model_to_lightweight_scene",
+    "prompt": "RBAC smoke engineer creates and runs.",
+    "actor": "rbac-engineer"
+  }'
+)"
+job_id="$(printf '%s\n' "${engineer_job}" | jq -r '.id')"
+printf '%s\n' "${engineer_job}" | jq -e --arg tenant "${tenant_a}" --arg project "${project}" '.context.tenantId == $tenant and .context.projectId == $project' >/dev/null
+
+auditor_status="$(
+  status_post_as "${tenant_a}" "${project}" "rbac-auditor" "auditor" '/v1/generation/jobs' '{
+    "moduleId": "digital_twin",
+    "mode": "text_to_bim",
+    "prompt": "auditor must not create",
+    "actor": "rbac-auditor"
+  }' /tmp/architoken-smoke-rbac-auditor-create.json
+)"
+test "${auditor_status}" = "403"
+jq -e '.code == 403 and (.error | contains("permission"))' /tmp/architoken-smoke-rbac-auditor-create.json >/dev/null
+
+post_as "${tenant_a}" "${project}" "rbac-engineer" "engineer" "/v1/generation/jobs/${job_id}/plan" '{"actor":"rbac-engineer","comment":"rbac plan"}' | jq -e '.status == "planned"' >/dev/null
+post_as "${tenant_a}" "${project}" "rbac-engineer" "engineer" "/v1/generation/jobs/${job_id}/run" '{"actor":"rbac-engineer","comment":"rbac run"}' | jq -e '.status == "pending_review"' >/dev/null
+
+post_as "${tenant_a}" "${project}" "rbac-reviewer" "reviewer" "/v1/generation/jobs/${job_id}/review" '{
+  "reviewer": "rbac-reviewer",
+  "decision": "approved",
+  "comment": "rbac review approved"
+}' | jq -e '.status == "pending_approval"' >/dev/null
+
+approved="$(
+  post_as "${tenant_a}" "${project}" "rbac-reviewer" "reviewer" "/v1/generation/jobs/${job_id}/approve" '{"actor":"rbac-reviewer","comment":"rbac approve"}'
+)"
+printf '%s\n' "${approved}" | jq -e '.status == "approved" and ([.artifacts[] | select(.status == "approved")] | length >= 3)' >/dev/null
+artifact_id="$(printf '%s\n' "${approved}" | jq -r '.artifacts[0].id')"
+
+get_as "${tenant_b}" "${project}" "rbac-auditor-b" "auditor" '/v1/generation/jobs' | jq -e --arg job_id "${job_id}" '[.jobs[] | select(.id == $job_id)] | length == 0' >/dev/null
+get_as "${tenant_b}" "${project}" "rbac-auditor-b" "auditor" "/v1/artifacts?source_job_id=${job_id}" | jq -e '.artifacts | length == 0' >/dev/null
+
+cross_get_status="$(
+  mapfile -t args < <(context_args_for "${tenant_b}" "${project}" "rbac-auditor-b" "auditor")
+  curl -sS -o /tmp/architoken-smoke-rbac-cross-artifact.json -w '%{http_code}' \
+    "${BASE_URL}/v1/artifacts/${artifact_id}" \
+    "${args[@]}" \
+    -H 'Accept: application/json'
+)"
+test "${cross_get_status}" = "403"
+jq -e '.code == 403' /tmp/architoken-smoke-rbac-cross-artifact.json >/dev/null
+
+printf 'rbac smoke passed, job_id=%s artifact_id=%s\n' "${job_id}" "${artifact_id}"
diff --git a/04-backend/scripts/smoke-registries.sh b/04-backend/scripts/smoke-registries.sh
index 718c3332..18c07fd5 100755
--- a/04-backend/scripts/smoke-registries.sh
+++ b/04-backend/scripts/smoke-registries.sh
@@ -1,25 +1,10 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-BASE_URL="${ARCHITOKEN_API_BASE_URL:-${BASE_URL:-http://localhost:8080}}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/smoke-context.sh"
 trap 'printf "smoke-registries failed at line %s against %s\n" "${LINENO}" "${BASE_URL}" >&2' ERR
 
-need_jq() {
-  if ! command -v jq >/dev/null 2>&1; then
-    printf 'jq is required for ArchIToken smoke scripts. Install jq and retry.\n' >&2
-    exit 1
-  fi
-}
-
-post_json() {
-  local path="$1"
-  local body="$2"
-  curl -fsS -X POST "${BASE_URL}${path}" \
-    -H 'Content-Type: application/json' \
-    -H 'Accept: application/json' \
-    --data "${body}"
-}
-
 need_jq
 
 skill_id="smoke-skill-$(date +%s)"
@@ -45,8 +30,8 @@ printf '%s\n' "${approved_skill}" | jq -e '.status == "approved" and .production
 blocked_status="$(
   curl -sS -o /tmp/architoken-smoke-blocked-skill.json -w '%{http_code}' \
     -X POST "${BASE_URL}/v1/skills" \
-    -H 'Content-Type: application/json' \
-    -H 'Accept: application/json' \
+    "${context_headers[@]}" \
+    "${json_headers[@]}" \
     --data "{
       \"id\": \"${skill_id}-blocked\",
       \"name\": \"Blocked Skill\",
@@ -108,6 +93,6 @@ source="$(
 printf '%s\n' "${source}" | jq -e '.status == "candidate_only" and .productionEnabled == false and .defaultRoute == "disabled"' >/dev/null
 
 post_json "/v1/knowledge-sources/${source_id}/ingest" '{"actor":"smoke","comment":"candidate mock ingest"}' | jq -e '.status == "completed"' >/dev/null
-curl -fsS "${BASE_URL}/v1/knowledge-sources/${source_id}" | jq -e '.status == "candidate_only" and .productionEnabled == false and .defaultRoute == "disabled"' >/dev/null
+get_json "/v1/knowledge-sources/${source_id}" | jq -e '.status == "candidate_only" and .productionEnabled == false and .defaultRoute == "disabled"' >/dev/null
 
 printf 'registry smoke passed\n'
diff --git a/04-backend/scripts/smoke-viewer-commands.sh b/04-backend/scripts/smoke-viewer-commands.sh
index be9ae16d..0be2b290 100755
--- a/04-backend/scripts/smoke-viewer-commands.sh
+++ b/04-backend/scripts/smoke-viewer-commands.sh
@@ -1,29 +1,14 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-BASE_URL="${ARCHITOKEN_API_BASE_URL:-${BASE_URL:-http://localhost:8080}}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/smoke-context.sh"
 trap 'printf "smoke-viewer-commands failed at line %s against %s\n" "${LINENO}" "${BASE_URL}" >&2' ERR
 
-need_jq() {
-  if ! command -v jq >/dev/null 2>&1; then
-    printf 'jq is required for ArchIToken smoke scripts. Install jq and retry.\n' >&2
-    exit 1
-  fi
-}
-
-post_json() {
-  local path="$1"
-  local body="$2"
-  curl -fsS -X POST "${BASE_URL}${path}" \
-    -H 'Content-Type: application/json' \
-    -H 'Accept: application/json' \
-    --data "${body}"
-}
-
 need_jq
 
 if [[ ! -s /tmp/architoken-smoke-artifact-id ]]; then
-  "$(dirname "$0")/smoke-generation.sh"
+  "${SCRIPT_DIR}/smoke-generation.sh"
 fi
 
 artifact_id="$(cat /tmp/architoken-smoke-artifact-id)"
@@ -51,7 +36,7 @@ acked="$(
 )"
 printf '%s\n' "${acked}" | jq -e '.status == "executed" and .acknowledgedBy == "smoke-viewer"' >/dev/null
 
-curl -fsS "${BASE_URL}/v1/viewer/commands/${command_id}" | jq -e '.status == "executed"' >/dev/null
-curl -fsS "${BASE_URL}/v1/viewer/commands?status=executed" | jq -e --arg command_id "${command_id}" '.commands[] | select(.id == $command_id)' >/dev/null
+get_json "/v1/viewer/commands/${command_id}" | jq -e '.status == "executed"' >/dev/null
+get_json '/v1/viewer/commands?status=executed' | jq -e --arg command_id "${command_id}" '.commands[] | select(.id == $command_id)' >/dev/null
 
 printf 'viewer command smoke passed, command_id=%s\n' "${command_id}"
diff --git a/docs/06_FRONTEND_BACKEND_INTEGRATION_GUIDE.md b/docs/06_FRONTEND_BACKEND_INTEGRATION_GUIDE.md
index d33ec8d3..10f36775 100644
--- a/docs/06_FRONTEND_BACKEND_INTEGRATION_GUIDE.md
+++ b/docs/06_FRONTEND_BACKEND_INTEGRATION_GUIDE.md
@@ -2,11 +2,13 @@
 
 ## Local Runtime
 
-Phase 5 still uses the mock/in-memory/dev persistence boundary. It does not
+Phase 6 still uses the mock/in-memory/dev persistence boundary. It does not
 call real model providers, add database migrations, or persist production
 artifact bytes. Artifact APIs expose stable metadata, versions, storage
 bindings, and `memory://` object references so the implementation can later be
 replaced behind `ObjectStore`/`StorageRouter` without changing frontend calls.
+The Phase 6 additions are `RequestContext`, `PermissionGuard`, tenant/project
+isolation, and explicit durable store trait boundaries.
 
 Backend:
 
@@ -34,10 +36,29 @@ http://localhost:3000/app/dev/api-lab
 
 The page can load runtime capabilities, create and approve a generation job, list standalone artifacts, and submit plus execute a viewer command.
 
-The API Lab shows backend base URL, runtime capability status, generation job
-id/status, first artifact id, viewer command id/status, and an error panel. It
-uses the checked-in fetch clients under `03-frontend/lib/*-client.ts`; generated
-SDK output is not imported into the repo.
+The API Lab shows backend base URL, context inputs, runtime capability status,
+generation job id/status, first artifact id, viewer command id/status, and an
+error panel that preserves 403 response bodies. It uses the checked-in fetch
+clients under `03-frontend/lib/*-client.ts`; generated SDK output is not
+imported into the repo.
+
+## Request Context Headers
+
+All runtime, generation, artifact, registry, knowledge source, and viewer
+command calls should carry:
+
+```bash
+-H 'X-Tenant-Id: tenant-demo' \
+-H 'X-Project-Id: project-demo' \
+-H 'X-Actor: engineer@example.com' \
+-H 'X-Roles: engineer' \
+-H 'X-Request-Id: req-20260430-001' \
+-H 'X-Correlation-Id: corr-phase6-demo'
+```
+
+Development may fall back to a dev context. Production-like profiles must not
+rely on weak fallback. Third-party frontends and AI agents call the same
+endpoints with the same headers.
 
 ## Runtime Capabilities
 
@@ -120,3 +141,6 @@ No `OptRapid3dLoader.js`, EXE, proprietary SDK, or proprietary JS package is req
 OpenAPI 3.1 validation is expected to keep only the existing local dev server
 warning for `http://localhost:8080`; new Phase 5 endpoints and examples should
 not add warnings.
+
+Phase 6 keeps the target warning count at 1 and adds `RequestContext`,
+`PermissionDecision`, and `RuntimeStoreCapabilities` schemas.
diff --git a/docs/07_API_SMOKE_TEST_GUIDE.md b/docs/07_API_SMOKE_TEST_GUIDE.md
index f6eae197..31cd0183 100644
--- a/docs/07_API_SMOKE_TEST_GUIDE.md
+++ b/docs/07_API_SMOKE_TEST_GUIDE.md
@@ -18,6 +18,15 @@ cargo run --bin insomeos-gateway
 Default `ARCHITOKEN_API_BASE_URL` is `http://localhost:8080`. `BASE_URL` is
 still accepted as a compatibility fallback.
 
+Phase 6 smoke scripts also accept:
+
+```bash
+ARCHITOKEN_TENANT_ID=smoke-tenant
+ARCHITOKEN_PROJECT_ID=smoke-project
+ARCHITOKEN_ACTOR=smoke
+ARCHITOKEN_ROLES=admin
+```
+
 ## Scripts
 
 ```bash
@@ -27,13 +36,19 @@ cd 04-backend
 ./scripts/smoke-artifacts.sh
 ./scripts/smoke-registries.sh
 ./scripts/smoke-viewer-commands.sh
+./scripts/smoke-rbac.sh
 ./scripts/smoke-all.sh
 ```
 
 Override target:
 
 ```bash
-ARCHITOKEN_API_BASE_URL=http://localhost:8080 ./scripts/smoke-all.sh
+ARCHITOKEN_API_BASE_URL=http://localhost:8080 \
+ARCHITOKEN_TENANT_ID=smoke-tenant \
+ARCHITOKEN_PROJECT_ID=smoke-project \
+ARCHITOKEN_ACTOR=smoke \
+ARCHITOKEN_ROLES=admin \
+./scripts/smoke-all.sh
 ```
 
 ## Coverage
@@ -48,9 +63,12 @@ ARCHITOKEN_API_BASE_URL=http://localhost:8080 ./scripts/smoke-all.sh
 
 `smoke-viewer-commands.sh` creates a `set_color` viewer command against a generated artifact, marks it as `executed`, and verifies command listing.
 
+`smoke-rbac.sh` verifies engineer create/run, auditor create denial with HTTP
+403, reviewer review/approve, and cross-tenant job/artifact list isolation.
+
 ## Known Limitations
 
-The runtime is `in_memory_preview`. It does not persist real artifact bytes, does not call commercial model APIs, and does not enable proprietary vendor routes. Phase 5 smoke validates the persistence boundary, not production storage.
+The runtime is `in_memory_preview`. It does not persist real artifact bytes, does not call commercial model APIs, and does not enable proprietary vendor routes. Phase 6 smoke validates the durable-store/RBAC boundary, not production storage or a production database.
 
 OpenAPI lint is expected to keep only the existing localhost development server warning. SDK generation output must go to `/tmp/architoken-sdk-ts`; generated SDK files are not committed.
 
diff --git a/docs/08_PHASE4_RUNTIME_READINESS_REPORT.md b/docs/08_PHASE4_RUNTIME_READINESS_REPORT.md
index 0e59de36..0595b01c 100644
--- a/docs/08_PHASE4_RUNTIME_READINESS_REPORT.md
+++ b/docs/08_PHASE4_RUNTIME_READINESS_REPORT.md
@@ -77,6 +77,11 @@ OpenAPI warning count changed from 21 to 1. The remaining warning is the documen
 
 The runtime is `in_memory_preview`; it does not persist real bytes, add DB migrations, call real commercial model APIs, or enable proprietary vendor routes.
 
+Phase 6 extends this runtime with `RequestContext`, `PermissionGuard`, durable
+store trait boundaries, and tenant/project isolation while keeping the same
+mock/in-memory persistence boundary. Production database migrations should bind
+behind the store traits, not bypass service contracts.
+
 Open formats remain first: IFC, glTF, GLB, 3D Tiles, point cloud, SPZ, JSON, SQLite, DuckDB, and Parquet.
 
 No proprietary loader dependency is introduced. Do not import `OptRapid3dLoader.js`, proprietary JS packages, EXEs, or SDKs without legal, commercial, security, SBOM, benchmark, and explicit approval.
diff --git a/docs/10_PHASE6_DURABLE_STORE_RBAC_HANDOFF.md b/docs/10_PHASE6_DURABLE_STORE_RBAC_HANDOFF.md
new file mode 100644
index 00000000..357fc78b
--- /dev/null
+++ b/docs/10_PHASE6_DURABLE_STORE_RBAC_HANDOFF.md
@@ -0,0 +1,87 @@
+# Phase 6 Durable Store + RBAC Handoff
+
+Date: 2026-04-30
+
+## Scope
+
+Phase 6 hardens the Phase 5 runtime without connecting real infrastructure. The
+backend still uses in-memory stores and mock generation only. No database
+migration, real model call, Docker/K8s/infra change, proprietary loader, paid
+SDK, proprietary EXE, or proprietary JS package is part of this phase.
+
+## Runtime Boundaries
+
+- `RequestContext` carries `tenantId`, `projectId`, `actor`, `roles`,
+  `requestId`, and `correlationId`.
+- Gateway handlers accept `X-Tenant-Id`, `X-Project-Id`, `X-Actor`, `X-Roles`,
+  `X-Request-Id`, and `X-Correlation-Id`.
+- Development profile may fall back to a dev context; production-like profiles
+  reject weak tenant/project/actor/role fallback.
+- `PermissionGuard` currently uses an in-memory role policy: `admin` has all
+  permissions, `engineer` can create/run/write/viewer-create, `reviewer` can
+  review/approve/read, and `auditor` is read-only.
+- Store traits define replacement boundaries for `ObjectStore`,
+  `TransactionStore`, `EventStore`, `RegistryStore`, `ArtifactStore`,
+  `ViewerCommandStore`, and `KnowledgeSourceStore`.
+
+## DB/ObjectStore Migration Points
+
+Future DB/ObjectStore/EventStore adapters should replace the in-memory services
+behind the existing traits. They must preserve `HarnessResult` errors,
+deterministic pagination, `createdAt`/`updatedAt`/`version`, owner,
+tenant/project isolation, and audit/context metadata.
+
+## Local Run
+
+Backend:
+
+```bash
+cd 04-backend
+cargo run --bin insomeos-gateway
+```
+
+Frontend API Lab:
+
+```bash
+cd 03-frontend
+NEXT_PUBLIC_ARCHITOKEN_API_BASE_URL=http://localhost:8080 bun run dev
+```
+
+Open `/app/dev/api-lab`. The dev lab lets callers enter tenant id, project id,
+actor, and comma-separated roles. All requests go through the shared
+`backend-api` client and carry context headers.
+
+## Third-party / Agent Calls
+
+Third-party frontends and AI agents should call the same REST endpoints with the
+context headers above. Do not bypass the backend client in frontend code. A
+minimal generation request uses an `engineer` role for create/plan/run and a
+`reviewer` or `admin` role for review/approve.
+
+## Smoke
+
+```bash
+cd 04-backend
+ARCHITOKEN_API_BASE_URL=http://localhost:8080 \
+ARCHITOKEN_TENANT_ID=smoke-tenant \
+ARCHITOKEN_PROJECT_ID=smoke-project \
+ARCHITOKEN_ACTOR=smoke \
+ARCHITOKEN_ROLES=admin \
+./scripts/smoke-all.sh
+```
+
+`smoke-all.sh` runs health, runtime capabilities, generation lifecycle,
+artifacts, registries, viewer commands, and RBAC/cross-tenant isolation checks.
+
+## OpenAPI
+
+`openapi.yaml` remains OpenAPI 3.1 and includes context header parameters, 403
+responses, `RequestContext`, `PermissionDecision`, and
+`RuntimeStoreCapabilities`. The expected Redocly warning count remains one
+localhost development server warning.
+
+## Proprietary Boundary
+
+`vendor_optrapid3d` remains candidate-only metadata. `OptRapid3dLoader.js`,
+Glendale URLs, proprietary EXEs, proprietary SDKs, and paid/proprietary JS
+packages must not enter default production routes or the repository.