diff --git a/console/nginx/default.conf.template b/console/nginx/default.conf.template
index df5a26d4..f6523d73 100644
--- a/console/nginx/default.conf.template
+++ b/console/nginx/default.conf.template
@@ -58,6 +58,17 @@ server {
         proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
     }
 
+    # Public artifact viewer. The AES key lives only in the URL fragment, but
+    # these page-scoped headers also prevent referrer leakage, framing, stale
+    # decrypted navigation state, and unexpected network capabilities.
+    location ^~ /s/ {
+        add_header Referrer-Policy "no-referrer" always;
+        add_header Cache-Control "no-store" always;
+        add_header X-Content-Type-Options "nosniff" always;
+        add_header Content-Security-Policy "default-src 'none'; script-src 'self'; style-src 'self'; img-src 'self' data: blob:; font-src 'self'; connect-src 'self'; frame-src blob:; object-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'" always;
+        try_files $uri /index.html;
+    }
+
     # SPA fallback.
     location / {
         try_files $uri /index.html;
diff --git a/console/src/App.tsx b/console/src/App.tsx
index ffdf8ae6..9ca6fa95 100644
--- a/console/src/App.tsx
+++ b/console/src/App.tsx
@@ -1,6 +1,6 @@
 import { useEffect, useRef } from 'react';
 import { useTranslation } from 'react-i18next';
-import { Navigate, Route, Routes } from 'react-router-dom';
+import { Navigate, Route, Routes, useLocation } from 'react-router-dom';
 import { AppShell } from './components/AppShell';
 import { DeviceApiProvider } from './api/DeviceApiProvider';
 import { OnboardingGate } from './pages/OnboardingGate';
@@ -21,6 +21,7 @@ import { ClusterConnectionsPage } from './pages/ClusterConnectionsPage';
 import { DeviceAuthorizePage } from './pages/DeviceAuthorizePage';
 import { NotFoundPage } from './pages/NotFoundPage';
 import { SetupPage } from './pages/SetupPage';
+import { SharedArtifactPage } from './pages/SharedArtifactPage';
 import { useToast } from './components/Toast';
 import { readQueryParam, stripQueryParams } from './lib/url';
 
@@ -56,6 +57,14 @@ function useLinkFlash() {
 }
 
 export function App() {
+  const location = useLocation();
+  if (location.pathname.startsWith('/s/')) {
+    return <Routes><Route path="/s/:shareID" element={<SharedArtifactPage />} /><Route path="*" element={<NotFoundPage />} /></Routes>;
+  }
+  return <AuthenticatedApp />;
+}
+
+function AuthenticatedApp() {
   useLinkFlash();
   return (
     // The gate owns everything before a verified session exists: environment
diff --git a/console/src/lib/artifactShareCrypto.ts b/console/src/lib/artifactShareCrypto.ts
new file mode 100644
index 00000000..ad04ecf3
--- /dev/null
+++ b/console/src/lib/artifactShareCrypto.ts
@@ -0,0 +1,125 @@
+export const ARTIFACT_SHARE_PROTOCOL = 'jcode-artifact-share-v1' as const;
+
+export type ArtifactSharePart = 'metadata' | 'content';
+
+export type EncryptedArtifactMetadata = {
+  nonce: string;
+  ciphertext: string;
+  plaintext_length: number;
+};
+
+export type SharedArtifactEnvelope = {
+  share_id: string;
+  protocol: typeof ARTIFACT_SHARE_PROTOCOL;
+  artifact_id: string;
+  revision: number;
+  encrypted_metadata: EncryptedArtifactMetadata;
+  ciphertext_size: number;
+  ciphertext_sha256: string;
+  expires_at: string;
+};
+
+export type SharedArtifactMetadata = {
+  title: string;
+  relative_path: string;
+  media_type: string;
+  kind: string;
+  size: number;
+};
+
+const encoder = new TextEncoder();
+
+function exactArrayBuffer(bytes: Uint8Array): ArrayBuffer {
+  return Uint8Array.from(bytes).buffer;
+}
+
+export function artifactShareAAD(
+  shareId: string,
+  part: ArtifactSharePart,
+  artifactId: string,
+  revision: number,
+  plaintextLength: number,
+): Uint8Array {
+  if (!Number.isSafeInteger(revision) || revision <= 0 || !Number.isSafeInteger(plaintextLength) || plaintextLength < 0) {
+    throw new Error('artifact_decrypt_failed');
+  }
+  return encoder.encode(`${ARTIFACT_SHARE_PROTOCOL}\n${shareId}\n${part}\n${artifactId}\n${revision}\n${plaintextLength}`);
+}
+
+function fromBase64URL(value: string): Uint8Array {
+  if (!/^[A-Za-z0-9_-]+$/.test(value)) throw new Error('artifact_decrypt_failed');
+  const padded = value.replaceAll('-', '+').replaceAll('_', '/') + '='.repeat((4 - (value.length % 4)) % 4);
+  const binary = atob(padded);
+  return Uint8Array.from(binary, (char) => char.charCodeAt(0));
+}
+
+export function parseArtifactShareKey(hash: string): Uint8Array {
+  const match = /^#k=v1\.([A-Za-z0-9_-]{43})$/.exec(hash);
+  if (!match) throw new Error('artifact_decrypt_failed');
+  const key = fromBase64URL(match[1]!);
+  if (key.length !== 32) throw new Error('artifact_decrypt_failed');
+  return key;
+}
+
+async function importShareKey(key: Uint8Array): Promise<CryptoKey> {
+  return crypto.subtle.importKey('raw', exactArrayBuffer(key), 'AES-GCM', false, ['decrypt']);
+}
+
+async function decrypt(
+  key: CryptoKey,
+  nonce: Uint8Array,
+  ciphertext: Uint8Array,
+  aad: Uint8Array,
+): Promise<Uint8Array> {
+  if (nonce.length !== 12 || ciphertext.length < 16) throw new Error('artifact_decrypt_failed');
+  try {
+    return new Uint8Array(await crypto.subtle.decrypt({
+      name: 'AES-GCM',
+      iv: exactArrayBuffer(nonce),
+      additionalData: exactArrayBuffer(aad),
+    }, key, exactArrayBuffer(ciphertext)));
+  } catch {
+    throw new Error('artifact_decrypt_failed');
+  }
+}
+
+export async function decryptArtifactShare(
+  envelope: SharedArtifactEnvelope,
+  contentWire: Uint8Array,
+  keyBytes: Uint8Array,
+): Promise<{ metadata: SharedArtifactMetadata; content: Uint8Array }> {
+  if (envelope.protocol !== ARTIFACT_SHARE_PROTOCOL || contentWire.length !== envelope.ciphertext_size || contentWire.length < 28) {
+    throw new Error('artifact_decrypt_failed');
+  }
+  const digest = new Uint8Array(await crypto.subtle.digest('SHA-256', exactArrayBuffer(contentWire)));
+  const digestHex = Array.from(digest, (byte) => byte.toString(16).padStart(2, '0')).join('');
+	if (!/^[a-fA-F0-9]{64}$/.test(envelope.ciphertext_sha256) || digestHex !== envelope.ciphertext_sha256.toLowerCase()) {
+    throw new Error('artifact_decrypt_failed');
+  }
+  const key = await importShareKey(keyBytes);
+  const metadataEnvelope = envelope.encrypted_metadata;
+  const metadataPlaintext = await decrypt(
+    key,
+    fromBase64URL(metadataEnvelope.nonce),
+    fromBase64URL(metadataEnvelope.ciphertext),
+    artifactShareAAD(envelope.share_id, 'metadata', envelope.artifact_id, envelope.revision, metadataEnvelope.plaintext_length),
+  );
+  if (metadataPlaintext.length !== metadataEnvelope.plaintext_length) throw new Error('artifact_decrypt_failed');
+  const contentLength = envelope.ciphertext_size - 28;
+  const content = await decrypt(
+    key,
+    contentWire.slice(0, 12),
+    contentWire.slice(12),
+    artifactShareAAD(envelope.share_id, 'content', envelope.artifact_id, envelope.revision, contentLength),
+  );
+  if (content.length !== contentLength) throw new Error('artifact_decrypt_failed');
+  try {
+    const metadata = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(metadataPlaintext)) as SharedArtifactMetadata;
+    if (!metadata.title || !metadata.media_type || !metadata.kind || metadata.size !== content.length) {
+      throw new Error('artifact_decrypt_failed');
+    }
+    return { metadata, content };
+  } catch {
+    throw new Error('artifact_decrypt_failed');
+  }
+}
diff --git a/console/src/lib/artifactShareCrypto.vector.test.ts b/console/src/lib/artifactShareCrypto.vector.test.ts
new file mode 100644
index 00000000..7ef19bce
--- /dev/null
+++ b/console/src/lib/artifactShareCrypto.vector.test.ts
@@ -0,0 +1,72 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { decryptArtifactShare, parseArtifactShareKey, type SharedArtifactEnvelope } from './artifactShareCrypto';
+
+type Vector = {
+  protocol: 'jcode-artifact-share-v1';
+  share_id: string;
+  artifact_id: string;
+  revision: number;
+  key_b64url: string;
+  metadata_plaintext: string;
+  metadata_nonce_b64url: string;
+  metadata_ciphertext_b64url: string;
+  content_plaintext_b64url: string;
+  content_wire_b64url: string;
+  content_wire_sha256: string;
+};
+
+const decode = (value: string) => {
+  const padded = value.replaceAll('-', '+').replaceAll('_', '/') + '='.repeat((4 - value.length % 4) % 4);
+  return Uint8Array.from(atob(padded), (char) => char.charCodeAt(0));
+};
+
+describe('artifact share cross-runtime vector', () => {
+  it('decrypts the canonical JCode AES-GCM wire format in WebCrypto', async () => {
+    const vector = JSON.parse(readFileSync(resolve(process.cwd(), '../shared/artifact-share-v1.json'), 'utf8')) as Vector;
+    const metadataLength = new TextEncoder().encode(vector.metadata_plaintext).length;
+    const wire = decode(vector.content_wire_b64url);
+    const envelope: SharedArtifactEnvelope = {
+      share_id: vector.share_id,
+      protocol: vector.protocol,
+      artifact_id: vector.artifact_id,
+      revision: vector.revision,
+      encrypted_metadata: {
+        nonce: vector.metadata_nonce_b64url,
+        ciphertext: vector.metadata_ciphertext_b64url,
+        plaintext_length: metadataLength,
+      },
+      ciphertext_size: wire.length,
+      ciphertext_sha256: vector.content_wire_sha256,
+      expires_at: '2030-01-01T00:00:00Z',
+    };
+
+    const result = await decryptArtifactShare(envelope, wire, parseArtifactShareKey(`#k=v1.${vector.key_b64url}`));
+    expect(result.metadata).toEqual(JSON.parse(vector.metadata_plaintext));
+    expect(result.content).toEqual(decode(vector.content_plaintext_b64url));
+  });
+
+  it('fails closed when the ciphertext digest is absent', async () => {
+    const vector = JSON.parse(readFileSync(resolve(process.cwd(), '../shared/artifact-share-v1.json'), 'utf8')) as Vector;
+    const metadataLength = new TextEncoder().encode(vector.metadata_plaintext).length;
+    const wire = decode(vector.content_wire_b64url);
+    const envelope: SharedArtifactEnvelope = {
+      share_id: vector.share_id,
+      protocol: vector.protocol,
+      artifact_id: vector.artifact_id,
+      revision: vector.revision,
+      encrypted_metadata: {
+        nonce: vector.metadata_nonce_b64url,
+        ciphertext: vector.metadata_ciphertext_b64url,
+        plaintext_length: metadataLength,
+      },
+      ciphertext_size: wire.length,
+      ciphertext_sha256: '',
+      expires_at: '2030-01-01T00:00:00Z',
+    };
+
+    await expect(decryptArtifactShare(envelope, wire, parseArtifactShareKey(`#k=v1.${vector.key_b64url}`)))
+      .rejects.toThrow('artifact_decrypt_failed');
+  });
+});
diff --git a/console/src/nginxProxyConfig.test.ts b/console/src/nginxProxyConfig.test.ts
index 6e201769..22194b31 100644
--- a/console/src/nginxProxyConfig.test.ts
+++ b/console/src/nginxProxyConfig.test.ts
@@ -14,4 +14,15 @@ describe('console nginx edge contract', () => {
     expect(webhookLocation).toContain('proxy_pass ${ORCHESTRATOR_URL};');
     expect(config.indexOf('location /webhooks/')).toBeLessThan(config.indexOf('location / {'));
   });
+
+  it('serves public artifact routes with fragment-safe browser headers', () => {
+    const shareLocation = config.match(/location \^~ \/s\/ \{([\s\S]*?)\n    \}/)?.[1];
+
+    expect(shareLocation).toContain("try_files $uri /index.html;");
+    expect(shareLocation).toContain('Referrer-Policy "no-referrer" always');
+    expect(shareLocation).toContain('Cache-Control "no-store" always');
+    expect(shareLocation).toContain('Content-Security-Policy');
+    expect(shareLocation).toContain("frame-ancestors 'none'");
+    expect(config.indexOf('location ^~ /s/')).toBeLessThan(config.indexOf('location / {'));
+  });
 });
diff --git a/console/src/pages/SharedArtifactPage.module.css b/console/src/pages/SharedArtifactPage.module.css
new file mode 100644
index 00000000..377e7871
--- /dev/null
+++ b/console/src/pages/SharedArtifactPage.module.css
@@ -0,0 +1,21 @@
+.page { min-height: 100%; padding: var(--space-6); background: var(--color-bg); color: var(--color-text); }
+.header { display: flex; align-items: center; justify-content: space-between; max-width: 1120px; margin: 0 auto var(--space-6); }
+.brand { display: inline-flex; align-items: center; gap: var(--space-2); font-size: var(--fs-body); font-weight: var(--fw-semibold); }
+.brand svg { color: var(--color-accent); }
+.security { color: var(--color-text-dim); font-size: var(--fs-caption); }
+.status { display: grid; place-items: center; align-content: center; min-height: 70vh; gap: var(--space-3); text-align: center; }
+.status h1 { font-size: var(--fs-h1); }
+.status p { max-width: 36rem; color: var(--color-text-dim); }
+.spinner { width: var(--space-6); height: var(--space-6); border: 2px solid var(--color-border); border-top-color: var(--color-accent); border-radius: 50%; animation: spin 800ms linear infinite; }
+.artifact { max-width: 1120px; margin: 0 auto; overflow: hidden; border: 1px solid var(--color-border); border-radius: var(--radius-lg); background: var(--color-panel); box-shadow: var(--shadow-2); }
+.meta { display: flex; align-items: end; justify-content: space-between; gap: var(--space-6); padding: var(--space-6); border-bottom: 1px solid var(--color-border-subtle); }
+.meta p, .meta > span { color: var(--color-text-dim); font-family: var(--font-mono); font-size: var(--fs-caption); }
+.meta h1 { margin-top: var(--space-1); font-size: var(--fs-h1); }
+.viewer { min-height: min(72vh, 760px); padding: var(--space-6); }
+.text { overflow: auto; margin: 0; white-space: pre-wrap; font-family: var(--font-mono); line-height: 1.6; }
+.frame { width: 100%; min-height: min(66vh, 700px); border: 1px solid var(--color-border); border-radius: var(--radius-md); background: var(--color-bg-inset); }
+.image { display: block; max-width: 100%; max-height: 70vh; margin: 0 auto; object-fit: contain; }
+.download { display: inline-flex; align-items: center; gap: var(--space-2); color: var(--color-accent); }
+@keyframes spin { to { transform: rotate(360deg); } }
+@media (max-width: 640px) { .page { padding: var(--space-4); } .security, .meta > span { display: none; } .meta, .viewer { padding: var(--space-4); } }
+@media (prefers-reduced-motion: reduce) { .spinner { animation: none; } }
diff --git a/console/src/pages/SharedArtifactPage.test.tsx b/console/src/pages/SharedArtifactPage.test.tsx
new file mode 100644
index 00000000..08f6e81d
--- /dev/null
+++ b/console/src/pages/SharedArtifactPage.test.tsx
@@ -0,0 +1,117 @@
+import { render, screen, waitFor } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { App } from '../App';
+import { artifactShareAAD } from '../lib/artifactShareCrypto';
+
+const raw = (bytes: Uint8Array) =>
+  btoa(String.fromCharCode(...bytes)).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/, '');
+
+async function encrypt(
+  key: CryptoKey,
+  nonce: Uint8Array,
+  plaintext: Uint8Array,
+  aad: Uint8Array,
+): Promise<Uint8Array> {
+  return new Uint8Array(await crypto.subtle.encrypt({
+    name: 'AES-GCM',
+    iv: Uint8Array.from(nonce).buffer,
+    additionalData: Uint8Array.from(aad).buffer,
+  }, key, Uint8Array.from(plaintext).buffer));
+}
+
+async function mockEncryptedShare(options: {
+  shareId: string;
+  kind: string;
+  mediaType: string;
+  content: string;
+  title?: string;
+}) {
+  const artifactId = 'artifact-public';
+  const revision = 2;
+  const title = options.title ?? 'Artifact report';
+  const keyBytes = Uint8Array.from({ length: 32 }, (_, i) => i + 1);
+  const key = await crypto.subtle.importKey('raw', keyBytes, 'AES-GCM', false, ['encrypt']);
+  const contentPlaintext = new TextEncoder().encode(options.content);
+  const metadataPlaintext = new TextEncoder().encode(JSON.stringify({
+    title,
+    relative_path: `reports/result.${options.kind}`,
+    media_type: options.mediaType,
+    kind: options.kind,
+    size: contentPlaintext.length,
+  }));
+  const metadataNonce = Uint8Array.from({ length: 12 }, (_, i) => i + 11);
+  const contentNonce = Uint8Array.from({ length: 12 }, (_, i) => i + 31);
+  const metadataCiphertext = await encrypt(key, metadataNonce, metadataPlaintext, artifactShareAAD(options.shareId, 'metadata', artifactId, revision, metadataPlaintext.length));
+  const contentCiphertext = await encrypt(key, contentNonce, contentPlaintext, artifactShareAAD(options.shareId, 'content', artifactId, revision, contentPlaintext.length));
+  const contentWire = new Uint8Array(contentNonce.length + contentCiphertext.length);
+  contentWire.set(contentNonce);
+  contentWire.set(contentCiphertext, contentNonce.length);
+  const digest = new Uint8Array(await crypto.subtle.digest('SHA-256', Uint8Array.from(contentWire).buffer));
+  const digestHex = Array.from(digest, (byte) => byte.toString(16).padStart(2, '0')).join('');
+
+  vi.spyOn(globalThis, 'fetch')
+    .mockResolvedValueOnce(new Response(JSON.stringify({
+      share_id: options.shareId,
+      protocol: 'jcode-artifact-share-v1',
+      artifact_id: artifactId,
+      revision,
+      encrypted_metadata: {
+        nonce: raw(metadataNonce),
+        ciphertext: raw(metadataCiphertext),
+        plaintext_length: metadataPlaintext.length,
+      },
+      ciphertext_size: contentWire.length,
+      ciphertext_sha256: digestHex,
+      expires_at: '2026-08-02T12:00:00Z',
+    }), { status: 200, headers: { 'Content-Type': 'application/json' } }))
+    .mockResolvedValueOnce(new Response(contentWire, { status: 200, headers: { 'Content-Type': 'application/octet-stream' } }));
+
+  return keyBytes;
+}
+
+function renderShare(shareId: string, keyBytes: Uint8Array) {
+  render(<MemoryRouter initialEntries={[`/s/${shareId}#k=v1.${raw(keyBytes)}`]}><App /></MemoryRouter>);
+}
+
+describe('SharedArtifactPage', () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it('bypasses authenticated console boot, decrypts from the fragment, and renders safe text', async () => {
+    const shareId = 'share-public';
+    const keyBytes = await mockEncryptedShare({
+      shareId,
+      kind: 'markdown',
+      mediaType: 'text/markdown',
+      content: '# Result\n\nCiphertext only.',
+    });
+    renderShare(shareId, keyBytes);
+
+    expect(await screen.findByRole('heading', { name: 'Artifact report' })).toBeTruthy();
+    expect(screen.getByText(/Ciphertext only/)).toBeTruthy();
+    await waitFor(() => expect(fetch).toHaveBeenCalledTimes(2));
+    for (const call of vi.mocked(fetch).mock.calls) {
+      expect(String(call[0])).not.toContain('#k=');
+      expect(call[1]).toMatchObject({ credentials: 'omit', cache: 'no-store', referrerPolicy: 'no-referrer' });
+    }
+    expect(vi.mocked(fetch).mock.calls.some(([request]) => String(request).includes('/api/v1/me'))).toBe(false);
+  });
+
+  it('renders HTML artifacts in a script-capable sandbox without same-origin access', async () => {
+    const shareId = 'share-html';
+    const keyBytes = await mockEncryptedShare({
+      shareId,
+      kind: 'html',
+      mediaType: 'text/html',
+      content: '<script>document.body.textContent = "isolated"</script>',
+      title: 'HTML demo',
+    });
+    renderShare(shareId, keyBytes);
+
+    const frame = await screen.findByTitle('HTML demo');
+    expect(frame.getAttribute('sandbox')).toBe('allow-scripts');
+    expect(frame.getAttribute('sandbox')).not.toContain('allow-same-origin');
+    expect(frame.getAttribute('srcdoc')).toContain("default-src 'none'");
+    expect(frame.getAttribute('srcdoc')).toContain('<script>document.body.textContent = "isolated"</script>');
+  });
+});
diff --git a/console/src/pages/SharedArtifactPage.tsx b/console/src/pages/SharedArtifactPage.tsx
new file mode 100644
index 00000000..fdc3cd16
--- /dev/null
+++ b/console/src/pages/SharedArtifactPage.tsx
@@ -0,0 +1,103 @@
+import { DownloadSimple, LockKeyOpen } from '@phosphor-icons/react';
+import { useEffect, useMemo, useState } from 'react';
+import { useLocation, useParams } from 'react-router-dom';
+import { Markdown } from '../components/Markdown';
+import {
+  decryptArtifactShare,
+  parseArtifactShareKey,
+  type SharedArtifactEnvelope,
+  type SharedArtifactMetadata,
+} from '../lib/artifactShareCrypto';
+import styles from './SharedArtifactPage.module.css';
+
+type ViewState =
+  | { phase: 'loading' }
+  | { phase: 'error'; message: string }
+  | { phase: 'ready'; metadata: SharedArtifactMetadata; content: Uint8Array };
+
+const htmlCSP = "default-src 'none'; img-src data: blob:; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'none'; frame-src 'none'; object-src 'none'; base-uri 'none'; form-action 'none'";
+
+function escapedMarkdown(source: string): string {
+  return source.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+}
+
+function ArtifactContent({ metadata, content }: { metadata: SharedArtifactMetadata; content: Uint8Array }) {
+  const text = useMemo(() => {
+    if (!['markdown', 'text', 'code', 'csv'].includes(metadata.kind)) return '';
+    try { return new TextDecoder('utf-8', { fatal: true }).decode(content); } catch { return ''; }
+  }, [content, metadata.kind]);
+  const blobURL = useMemo(() => {
+    if (!['image', 'pdf', 'binary'].includes(metadata.kind) || typeof URL.createObjectURL !== 'function') return '';
+    return URL.createObjectURL(new Blob([Uint8Array.from(content).buffer], { type: metadata.media_type || 'application/octet-stream' }));
+  }, [content, metadata.kind, metadata.media_type]);
+  useEffect(() => () => { if (blobURL) URL.revokeObjectURL(blobURL); }, [blobURL]);
+
+  if (metadata.kind === 'markdown') return <Markdown source={escapedMarkdown(text)} />;
+  if (['text', 'code', 'csv'].includes(metadata.kind)) return <pre className={styles.text}>{text}</pre>;
+  if (metadata.kind === 'html') {
+    const source = new TextDecoder().decode(content);
+    return <iframe className={styles.frame} title={metadata.title} sandbox="allow-scripts" srcDoc={`<meta http-equiv="Content-Security-Policy" content="${htmlCSP}">${source}`} />;
+  }
+  if (metadata.kind === 'image' && blobURL) return <img className={styles.image} src={blobURL} alt={metadata.title} />;
+  if (metadata.kind === 'pdf' && blobURL) return <iframe className={styles.frame} title={metadata.title} src={blobURL} />;
+  return blobURL ? <a className={styles.download} href={blobURL} download={metadata.relative_path.split('/').at(-1)}><DownloadSimple size={18} />Download decrypted file</a> : <p>Preview is unavailable.</p>;
+}
+
+export function SharedArtifactPage() {
+  const { shareID = '' } = useParams();
+  const location = useLocation();
+  const [state, setState] = useState<ViewState>({ phase: 'loading' });
+  const key = useMemo(() => {
+    try { return parseArtifactShareKey(location.hash); } catch { return null; }
+  }, [location.hash]);
+
+  useEffect(() => {
+    if (location.hash) window.history.replaceState(null, '', location.pathname + location.search);
+  }, [location.hash, location.pathname, location.search]);
+
+  useEffect(() => {
+    if (!shareID || !key) {
+      setState({ phase: 'error', message: 'This share link is incomplete or invalid.' });
+      return;
+    }
+    const controller = new AbortController();
+    const options: RequestInit = { signal: controller.signal, credentials: 'omit', cache: 'no-store', referrerPolicy: 'no-referrer' };
+    void (async () => {
+      try {
+        const metadataResponse = await fetch(`/api/v1/shared-artifacts/${encodeURIComponent(shareID)}`, options);
+        if (!metadataResponse.ok) throw new Error('not_found');
+        const envelope = await metadataResponse.json() as SharedArtifactEnvelope;
+        const contentResponse = await fetch(`/api/v1/shared-artifacts/${encodeURIComponent(shareID)}/content`, options);
+        if (!contentResponse.ok) throw new Error('not_found');
+        const contentWire = new Uint8Array(await contentResponse.arrayBuffer());
+        const decrypted = await decryptArtifactShare(envelope, contentWire, key);
+        setState({ phase: 'ready', ...decrypted });
+      } catch (error) {
+        if (!controller.signal.aborted) {
+          setState({ phase: 'error', message: error instanceof Error && error.message === 'not_found' ? 'This share is unavailable or has expired.' : 'This share could not be decrypted.' });
+        }
+      }
+    })();
+    return () => controller.abort();
+  }, [key, shareID]);
+
+  return (
+    <main className={styles.page}>
+      <header className={styles.header}>
+        <div className={styles.brand}><LockKeyOpen size={19} weight="duotone" /><span>jcode Artifact</span></div>
+        <span className={styles.security}>End-to-end encrypted</span>
+      </header>
+      {state.phase === 'loading' && <section className={styles.status} role="status"><span className={styles.spinner} />Decrypting artifact…</section>}
+      {state.phase === 'error' && <section className={styles.status} role="alert"><h1>Artifact unavailable</h1><p>{state.message}</p></section>}
+      {state.phase === 'ready' && (
+        <article className={styles.artifact}>
+          <header className={styles.meta}>
+            <div><p>{state.metadata.kind} · {state.metadata.media_type}</p><h1>{state.metadata.title}</h1></div>
+            <span>{state.metadata.relative_path}</span>
+          </header>
+          <section className={styles.viewer}><ArtifactContent metadata={state.metadata} content={state.content} /></section>
+        </article>
+      )}
+    </main>
+  );
+}
diff --git a/console/src/test/setup.ts b/console/src/test/setup.ts
index cded89e1..4ef9a8b5 100644
--- a/console/src/test/setup.ts
+++ b/console/src/test/setup.ts
@@ -1,8 +1,16 @@
 import '@testing-library/dom';
+import { webcrypto } from 'node:crypto';
 // Initialise i18n so components rendered in tests resolve real English copy
 // (react-i18next uses the shared instance; without this, t() returns raw keys).
 import '../i18n';
 
+// jsdom exposes a Crypto shell without WebCrypto methods. Artifact-share and
+// device E2EE tests exercise the browser crypto contract with Node's standards-
+// compatible implementation.
+if (!globalThis.crypto?.subtle) {
+  Object.defineProperty(globalThis, 'crypto', { configurable: true, value: webcrypto });
+}
+
 // jsdom does not implement element scrolling. jcode-ui's stream-follow hook
 // intentionally uses scrollTo, so provide the browser API shape for component
 // tests without changing the production code path.
diff --git a/docs/11-api.md b/docs/11-api.md
index e1ebb8de..3069036d 100644
--- a/docs/11-api.md
+++ b/docs/11-api.md
@@ -653,6 +653,18 @@ data: {"seq":7,"ts":"2026-07-07T12:00:10Z","type":"agent.tool_call","payload":{"
   `Content-Disposition: attachment; filename="<run-id>.diff"`,body 为原始 diff。
 - 错误:`404`(产物尚不存在)。
 
+#### Device Artifact Shares — 端到端加密快照
+
+这组端点服务 JCode Desktop/Web 的显式分享，和 run diff artifact 不同。device 写路径使用 device bearer token；公开读路径不要求登录。Cloud 永远拿不到标题、路径、MIME、文件明文或 fragment key。
+
+1. `POST /internal/v1/device/artifact-shares/intents`：请求 `{protocol:"jcode-artifact-share-v1",artifact_id,revision,ciphertext_size,expires_in_seconds}`，响应 `201 {share_id,upload_url,complete_url,base_url,expires_at}`。`artifact_id` 只能是 1–128 字节 ASCII `[A-Za-z0-9_-]`；ciphertext 最大为 25 MiB + 28B 信封；有效期 1h–30d。
+2. `PUT /internal/v1/device/artifact-shares/{shareID}/content`：认证上传密文，`Content-Length` 必须与 intent 一致。成功 `204`；失败 lease 回收后可重试，object key 按 generation 隔离。
+3. `POST /internal/v1/device/artifact-shares/{shareID}/complete`：请求 `{ciphertext_sha256,encrypted_metadata:{nonce,ciphertext,plaintext_length}}`。成功后快照不可变。
+4. `GET /internal/v1/device/artifact-shares?artifact_id=…` 与 `DELETE /internal/v1/device/artifact-shares/{shareID}`：owner 管理与吊销；均不返回 key。
+5. `GET /api/v1/shared-artifacts/{shareID}` 与 `GET /api/v1/shared-artifacts/{shareID}/content`：公开读取密文。吊销、过期、未完成一律 `404`，响应带 `Cache-Control:no-store`、`Referrer-Policy:no-referrer`、`X-Content-Type-Options:nosniff`。
+
+密钥放在 public URL 的 `#k=v1.<base64url-32B>` fragment 中，浏览器不会把 fragment 发给服务端。AES-GCM wire、AAD 与跨端向量见 `docs/17` §6.8 和 `shared/artifact-share-v1.json`。
+
 ### 2.5 System / admin
 
 #### `GET /api/v1/system` — 集群管理只读快照
diff --git a/docs/17-jcode-device-relay.md b/docs/17-jcode-device-relay.md
index 7e315a01..e4f77efd 100644
--- a/docs/17-jcode-device-relay.md
+++ b/docs/17-jcode-device-relay.md
@@ -88,6 +88,10 @@ users ──< devices ──< device_sessions ──< device_events (seq 只追
 | GET | `/internal/v1/device/pairings?status=pending` | 列出本设备的配对请求（默认 pending）：`{pairings:[{id,label,created_at}]}`；超过 10 分钟的 pending 在此惰性结算为 expired（§6.3） |
 | POST | `/internal/v1/device/pairings/{pid}/respond` | 设备审批配对 `{approve, key_gen?, wrap?}`：approve 必须带当前 `key_gen` 与 ECIES 包裹的 CEK（`wrap`，原样存）；同结果重复 respond 幂等，竞争结果/旧代次 → 409；已过期 → 409 `pairing_expired`；他人配对 404 |
 | POST | `/internal/v1/device/revoke` | 吊销自己的 device token（`jcode logout`）：204，立即生效（下一个请求即 401，天然幂等） |
+| POST | `/internal/v1/device/artifact-shares/intents` | 创建加密 Artifact 快照 intent：只接收 `{protocol,artifact_id,revision,ciphertext_size,expires_in_seconds}`；不接收标题、路径、MIME 或明文内容。返回同源 upload/complete 路径与 public `base_url`。 |
+| PUT | `/internal/v1/device/artifact-shares/{shareID}/content` | 上传 `nonce(12B) || AES-256-GCM ciphertext+tag`；要求精确 `Content-Length`，Cloud 代理对象存储；lease/generation 防并发重试覆盖。 |
+| POST | `/internal/v1/device/artifact-shares/{shareID}/complete` | 用 ciphertext SHA-256 与加密 metadata envelope 完成不可变分享；同内容幂等，竞争完成返回 409。 |
+| GET/DELETE | `/internal/v1/device/artifact-shares[/{shareID}]` | device owner 列表/吊销；列表可按 opaque `artifact_id` 过滤，永不返回 fragment key。 |
 
 ### 4.2 下行（orchestrator → jcode，长轮询）
 
@@ -246,6 +250,18 @@ CEK 生成时同时可导出 24 词 recovery phrase（BIP39 编码 256bit，`jco
 - **门**：所有客户端下行指令端点（messages、stop、approval、workspace browse）在 `e2ee=true` 时只接受 `{envelope:{enc,...}}` 密文形式；明文 body 返回 **409 `{error:{code:"pairing_required"}}`**，不入队。客户端见此错误应引导配对（§6.3）拿 CEK 后改发密文。
 - **兼容**：`e2ee=false`（老 connector 或 `cloud.e2ee:false`）行为完全不变，明文路径照常放行——J8（e2ee:false 设备）明文发送不受影响即回归证据。
 
+### 6.8 Artifact 分享信封（Desktop/Web）
+
+Artifact 分享不复用账号 CEK，也不依赖 relay online。每次用户显式点击分享时，已登录的 JCode 设备生成独立随机 32B key；key 仅放在 `https://…/s/{shareID}#k=v1.<base64url-key>` 的 URL fragment 中，既不发送到 Cloud，也不写 session、日志或 WebSocket。未登录时本地 UI 完全隐藏分享入口。
+
+- 协议：`jcode-artifact-share-v1`，单快照明文上限 25 MiB，过期时间 1 小时到 30 天。
+- content wire：`12B nonce || AES-256-GCM(ciphertext || 16B tag)`。
+- metadata：`{title,relative_path,media_type,kind,size}` 先编码为 UTF-8 JSON，再独立 nonce + AES-GCM；Cloud 仅保存 `{nonce,ciphertext,plaintext_length}`。
+- AAD：`protocol + "\n" + share_id + "\n" + ("metadata"|"content") + "\n" + artifact_id + "\n" + revision + "\n" + plaintext_length`。
+- public API：`GET /api/v1/shared-artifacts/{shareID}` 只返回密文元数据/摘要；`GET …/content` 由 Cloud 代理对象存储并返回密文，两个端点均为 unauthenticated、`no-store`、`no-referrer`、`nosniff`。撤销或过期后一律 404。
+- public viewer：先从 fragment 取 key 并立刻从地址栏移除，再请求密文；HTML 仅在 opaque-origin iframe（`sandbox="allow-scripts"`、无 `allow-same-origin`）渲染，页面 CSP 禁止 connect/object/base/form。
+- 跨实现标准向量：`shared/artifact-share-v1.json`；JCode Go 与 Cloud Console WebCrypto 测试必须共同读取该文件。
+
 ## 7. 客户端
 
 ### 7.1 cloud console（M4）
diff --git a/orchestrator/internal/api/api.go b/orchestrator/internal/api/api.go
index 70fa7666..7b6af92a 100644
--- a/orchestrator/internal/api/api.go
+++ b/orchestrator/internal/api/api.go
@@ -358,6 +358,10 @@ func (s *Server) Handler() http.Handler {
 
 	// Health (unauthenticated).
 	mux.HandleFunc("GET /healthz", s.handleHealth)
+	// Public encrypted Artifact snapshots. These routes never receive the URL
+	// fragment key and deliberately bypass auth/onboarding.
+	mux.HandleFunc("GET /api/v1/shared-artifacts/{shareID}", s.handleGetSharedArtifact)
+	mux.HandleFunc("GET /api/v1/shared-artifacts/{shareID}/content", s.handleGetSharedArtifactContent)
 
 	// Provider webhooks are always present and authenticate against the
 	// DB-backed cluster Provider config. A missing/invalid config is fail-visible;
@@ -633,6 +637,11 @@ func (s *Server) Handler() http.Handler {
 	mux.Handle("/internal/v1/device/cloud-models/{model_id}/llm/{rest...}", s.authed(s.handleDeviceCloudModelProxy))
 	mux.Handle("POST /internal/v1/device/pairing-offers", s.authed(s.handleCreatePairingOffer))
 	mux.Handle("POST /internal/v1/device/revoke", s.authed(s.handleDeviceRevoke))
+	mux.Handle("POST /internal/v1/device/artifact-shares/intents", s.authed(s.handleCreateArtifactShareIntent))
+	mux.Handle("PUT /internal/v1/device/artifact-shares/{shareID}/content", s.authed(s.handleUploadArtifactShareContent))
+	mux.Handle("POST /internal/v1/device/artifact-shares/{shareID}/complete", s.authed(s.handleCompleteArtifactShare))
+	mux.Handle("GET /internal/v1/device/artifact-shares", s.authed(s.handleListArtifactShares))
+	mux.Handle("DELETE /internal/v1/device/artifact-shares/{shareID}", s.authed(s.handleRevokeArtifactShare))
 	mux.Handle("POST /internal/v1/runs/{id}/artifact", s.runToken(s.handleIngestArtifact))
 	// The source endpoint remains retired: provider credentials are injected for
 	// the checkout. Delivery is different: the credential-free runner uploads a
diff --git a/orchestrator/internal/api/device_artifact_shares.go b/orchestrator/internal/api/device_artifact_shares.go
new file mode 100644
index 00000000..ad137339
--- /dev/null
+++ b/orchestrator/internal/api/device_artifact_shares.go
@@ -0,0 +1,335 @@
+package api
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"io"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/cnjack/jcloud/internal/domain"
+	"github.com/cnjack/jcloud/internal/store"
+)
+
+const (
+	artifactShareMaxPlaintext     = int64(25 << 20)
+	artifactShareEnvelopeOverhead = int64(28)
+	artifactShareMaxCiphertext    = artifactShareMaxPlaintext + artifactShareEnvelopeOverhead
+	artifactShareMaxMetadataJSON  = int64(64 << 10)
+	artifactShareIntentTTL        = time.Hour
+	artifactShareUploadLease      = 5 * time.Minute
+	artifactShareUploadURLTTL     = 10 * time.Minute
+	artifactShareMaxActiveCount   = 100
+	artifactShareMaxActiveBytes   = int64(1 << 30)
+	artifactShareMinExpiry        = time.Hour
+	artifactShareMaxExpiry        = 30 * 24 * time.Hour
+	artifactShareCleanupTimeout   = 30 * time.Second
+)
+
+type artifactShareIntentRequest struct {
+	Protocol         string `json:"protocol"`
+	ArtifactID       string `json:"artifact_id"`
+	Revision         int    `json:"revision"`
+	CiphertextSize   int64  `json:"ciphertext_size"`
+	ExpiresInSeconds int64  `json:"expires_in_seconds"`
+}
+
+type artifactShareCompleteRequest struct {
+	CiphertextSHA256  string                           `json:"ciphertext_sha256"`
+	EncryptedMetadata domain.EncryptedArtifactMetadata `json:"encrypted_metadata"`
+}
+
+func (s *Server) handleCreateArtifactShareIntent(w http.ResponseWriter, r *http.Request) {
+	p := s.requireDevice(w, r)
+	if p == nil {
+		return
+	}
+	if s.attachmentStore == nil {
+		writeError(w, http.StatusConflict, "artifact_share_unavailable", "object storage is not configured")
+		return
+	}
+	var req artifactShareIntentRequest
+	if err := decodeBoundedJSON(w, r, &req, 4096); err != nil {
+		writeError(w, http.StatusBadRequest, "bad_request", "invalid artifact share intent")
+		return
+	}
+	if req.Protocol != domain.ArtifactShareProtocolV1 || !validOpaqueArtifactID(req.ArtifactID) || req.Revision <= 0 ||
+		req.CiphertextSize < artifactShareEnvelopeOverhead || req.CiphertextSize > artifactShareMaxCiphertext {
+		writeError(w, http.StatusBadRequest, "bad_request", "artifact share intent is invalid")
+		return
+	}
+	expiresIn := time.Duration(req.ExpiresInSeconds) * time.Second
+	if expiresIn < artifactShareMinExpiry || expiresIn > artifactShareMaxExpiry {
+		writeError(w, http.StatusBadRequest, "bad_request", "artifact share expiry is invalid")
+		return
+	}
+	now := time.Now().UTC()
+	share := &domain.ArtifactShare{
+		ID: domain.NewID(), UserID: p.deviceUserID, DeviceID: p.deviceID,
+		ArtifactID: req.ArtifactID, Revision: req.Revision, Protocol: req.Protocol,
+		State: domain.ArtifactSharePending, CiphertextSize: req.CiphertextSize,
+		IntentExpiresAt: now.Add(artifactShareIntentTTL), ExpiresAt: now.Add(expiresIn), CreatedAt: now,
+	}
+	if err := s.st.CreateArtifactShare(r.Context(), share, artifactShareMaxActiveCount, artifactShareMaxActiveBytes); err != nil {
+		if errors.Is(err, store.ErrArtifactShareQuotaExceeded) {
+			writeError(w, http.StatusTooManyRequests, "artifact_share_quota_exceeded", "artifact share quota exceeded")
+			return
+		}
+		s.log.Error("create artifact share intent", "err", err)
+		writeError(w, http.StatusInternalServerError, "internal", "could not create artifact share")
+		return
+	}
+	baseURL := strings.TrimRight(s.cfg.ConsoleURL, "/") + "/s/" + share.ID
+	writeJSON(w, http.StatusCreated, map[string]any{
+		"share_id":     share.ID,
+		"upload_url":   "/internal/v1/device/artifact-shares/" + share.ID + "/content",
+		"complete_url": "/internal/v1/device/artifact-shares/" + share.ID + "/complete",
+		"base_url":     baseURL,
+		"expires_at":   share.ExpiresAt,
+	})
+}
+
+func validOpaqueArtifactID(id string) bool {
+	if len(id) < 1 || len(id) > 128 {
+		return false
+	}
+	for i := 0; i < len(id); i++ {
+		char := id[i]
+		if !((char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') ||
+			(char >= '0' && char <= '9') || char == '-' || char == '_') {
+			return false
+		}
+	}
+	return true
+}
+
+func decodeBoundedJSON(w http.ResponseWriter, r *http.Request, dst any, limit int64) error {
+	r.Body = http.MaxBytesReader(w, r.Body, limit)
+	dec := json.NewDecoder(r.Body)
+	dec.DisallowUnknownFields()
+	if err := dec.Decode(dst); err != nil {
+		return err
+	}
+	if err := dec.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
+		return errors.New("trailing JSON")
+	}
+	return nil
+}
+
+func (s *Server) handleUploadArtifactShareContent(w http.ResponseWriter, r *http.Request) {
+	p := s.requireDevice(w, r)
+	if p == nil {
+		return
+	}
+	if s.attachmentStore == nil {
+		writeError(w, http.StatusConflict, "artifact_share_unavailable", "object storage is not configured")
+		return
+	}
+	now := time.Now().UTC()
+	claimID := domain.NewID()
+	share, err := s.st.ClaimArtifactShareUpload(r.Context(), r.PathValue("shareID"), p.deviceUserID, claimID, now, now.Add(artifactShareUploadLease))
+	if err != nil {
+		writeError(w, http.StatusConflict, "artifact_share_conflict", "artifact share upload is unavailable")
+		return
+	}
+	cleanup := func() {
+		cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(r.Context()), artifactShareCleanupTimeout)
+		defer cancel()
+		if s.st.ReleaseArtifactShareUpload(cleanupCtx, share.ID, p.deviceUserID, claimID, share.UploadGeneration) {
+			_ = s.attachmentStore.Delete(cleanupCtx, share.ObjectKey)
+		}
+	}
+	if r.ContentLength != share.CiphertextSize {
+		cleanup()
+		writeError(w, http.StatusBadRequest, "artifact_share_size_mismatch", "content length must equal ciphertext_size")
+		return
+	}
+	putURL, err := s.attachmentStore.PresignPut(share.ObjectKey, artifactShareUploadURLTTL)
+	if err != nil {
+		cleanup()
+		writeError(w, http.StatusBadGateway, "object_store_error", "could not prepare artifact upload")
+		return
+	}
+	body := http.MaxBytesReader(w, r.Body, share.CiphertextSize+1)
+	defer func() { _ = body.Close() }()
+	hash := sha256.New()
+	forward, err := http.NewRequestWithContext(r.Context(), http.MethodPut, putURL, io.TeeReader(io.LimitReader(body, share.CiphertextSize), hash))
+	if err != nil {
+		cleanup()
+		writeError(w, http.StatusBadGateway, "object_store_error", "could not prepare artifact upload")
+		return
+	}
+	forward.ContentLength = share.CiphertextSize
+	forward.Header.Set("Content-Type", "application/octet-stream")
+	resp, err := (&http.Client{Timeout: artifactShareUploadLease}).Do(forward)
+	if err != nil || resp.StatusCode/100 != 2 {
+		if resp != nil {
+			_ = resp.Body.Close()
+		}
+		cleanup()
+		writeError(w, http.StatusBadGateway, "object_store_error", "artifact upload failed")
+		return
+	}
+	_ = resp.Body.Close()
+	var extra [1]byte
+	if n, _ := body.Read(extra[:]); n != 0 {
+		cleanup()
+		writeError(w, http.StatusBadRequest, "artifact_share_size_mismatch", "artifact body exceeds ciphertext_size")
+		return
+	}
+	storedSize, _, err := s.attachmentStore.Stat(r.Context(), share.ObjectKey)
+	if err != nil || storedSize != share.CiphertextSize {
+		cleanup()
+		writeError(w, http.StatusBadGateway, "object_store_error", "artifact upload could not be verified")
+		return
+	}
+	digest := hex.EncodeToString(hash.Sum(nil))
+	if err := s.st.MarkArtifactShareUploaded(r.Context(), share.ID, p.deviceUserID, claimID, share.UploadGeneration, digest, time.Now().UTC()); err != nil {
+		cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(r.Context()), artifactShareCleanupTimeout)
+		defer cancel()
+		_ = s.attachmentStore.Delete(cleanupCtx, share.ObjectKey)
+		writeError(w, http.StatusConflict, "artifact_share_conflict", "artifact upload lease was superseded")
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func (s *Server) handleCompleteArtifactShare(w http.ResponseWriter, r *http.Request) {
+	p := s.requireDevice(w, r)
+	if p == nil {
+		return
+	}
+	var req artifactShareCompleteRequest
+	if err := decodeBoundedJSON(w, r, &req, artifactShareMaxMetadataJSON+4096); err != nil || !validArtifactShareComplete(req) {
+		writeError(w, http.StatusBadRequest, "bad_request", "artifact share completion is invalid")
+		return
+	}
+	share, err := s.st.CompleteArtifactShare(r.Context(), r.PathValue("shareID"), p.deviceUserID, strings.ToLower(req.CiphertextSHA256), req.EncryptedMetadata, time.Now().UTC())
+	if err != nil {
+		if errors.Is(err, store.ErrNotFound) {
+			writeError(w, http.StatusNotFound, "not_found", "artifact share not found")
+			return
+		}
+		writeError(w, http.StatusConflict, "artifact_share_conflict", "artifact share cannot be completed")
+		return
+	}
+	writeJSON(w, http.StatusOK, ownerArtifactShareView(share))
+}
+
+func validArtifactShareComplete(req artifactShareCompleteRequest) bool {
+	digest, err := hex.DecodeString(req.CiphertextSHA256)
+	if err != nil || len(digest) != sha256.Size || req.EncryptedMetadata.PlaintextLength < 0 {
+		return false
+	}
+	nonce, err := base64.RawURLEncoding.DecodeString(req.EncryptedMetadata.Nonce)
+	if err != nil || len(nonce) != 12 {
+		return false
+	}
+	ciphertext, err := base64.RawURLEncoding.DecodeString(req.EncryptedMetadata.Ciphertext)
+	return err == nil && int64(len(ciphertext)) == req.EncryptedMetadata.PlaintextLength+16
+}
+
+func ownerArtifactShareView(share *domain.ArtifactShare) map[string]any {
+	return map[string]any{
+		"share_id": share.ID, "artifact_id": share.ArtifactID, "revision": share.Revision,
+		"protocol": share.Protocol, "state": share.State, "ciphertext_size": share.CiphertextSize,
+		"ciphertext_sha256": share.CiphertextSHA256, "expires_at": share.ExpiresAt,
+		"completed_at": share.CompletedAt, "revoked_at": share.RevokedAt, "created_at": share.CreatedAt,
+	}
+}
+
+func (s *Server) handleListArtifactShares(w http.ResponseWriter, r *http.Request) {
+	p := s.requireDevice(w, r)
+	if p == nil {
+		return
+	}
+	shares, err := s.st.ListArtifactSharesForUser(r.Context(), p.deviceUserID, r.URL.Query().Get("artifact_id"))
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "internal", "could not list artifact shares")
+		return
+	}
+	views := make([]map[string]any, 0, len(shares))
+	for i := range shares {
+		views = append(views, ownerArtifactShareView(&shares[i]))
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"shares": views})
+}
+
+func (s *Server) handleRevokeArtifactShare(w http.ResponseWriter, r *http.Request) {
+	p := s.requireDevice(w, r)
+	if p == nil {
+		return
+	}
+	if _, err := s.st.RevokeArtifactShare(r.Context(), r.PathValue("shareID"), p.deviceUserID, time.Now().UTC()); err != nil {
+		if errors.Is(err, store.ErrNotFound) {
+			writeError(w, http.StatusNotFound, "not_found", "artifact share not found")
+			return
+		}
+		writeError(w, http.StatusInternalServerError, "internal", "could not revoke artifact share")
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func setPublicArtifactHeaders(w http.ResponseWriter) {
+	w.Header().Set("Cache-Control", "no-store")
+	w.Header().Set("Referrer-Policy", "no-referrer")
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+}
+
+func (s *Server) handleGetSharedArtifact(w http.ResponseWriter, r *http.Request) {
+	setPublicArtifactHeaders(w)
+	share, err := s.st.GetPublicArtifactShare(r.Context(), r.PathValue("shareID"), time.Now().UTC())
+	if err != nil {
+		writeError(w, http.StatusNotFound, "not_found", "shared artifact not found")
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{
+		"share_id": share.ID, "protocol": share.Protocol, "artifact_id": share.ArtifactID,
+		"revision": share.Revision, "encrypted_metadata": share.EncryptedMetadata,
+		"ciphertext_size": share.CiphertextSize, "ciphertext_sha256": share.CiphertextSHA256,
+		"expires_at": share.ExpiresAt,
+	})
+}
+
+func (s *Server) handleGetSharedArtifactContent(w http.ResponseWriter, r *http.Request) {
+	setPublicArtifactHeaders(w)
+	share, err := s.st.GetPublicArtifactShare(r.Context(), r.PathValue("shareID"), time.Now().UTC())
+	if err != nil || s.attachmentStore == nil {
+		writeError(w, http.StatusNotFound, "not_found", "shared artifact not found")
+		return
+	}
+	getURL, err := s.attachmentStore.PresignGet(share.ObjectKey, artifactShareUploadURLTTL)
+	if err != nil {
+		writeError(w, http.StatusBadGateway, "object_store_error", "shared artifact content is unavailable")
+		return
+	}
+	request, err := http.NewRequestWithContext(r.Context(), http.MethodGet, getURL, nil)
+	if err != nil {
+		writeError(w, http.StatusBadGateway, "object_store_error", "shared artifact content is unavailable")
+		return
+	}
+	resp, err := (&http.Client{Timeout: artifactShareUploadLease}).Do(request)
+	if err != nil || resp.StatusCode/100 != 2 {
+		if resp != nil {
+			_ = resp.Body.Close()
+		}
+		writeError(w, http.StatusBadGateway, "object_store_error", "shared artifact content is unavailable")
+		return
+	}
+	defer func() { _ = resp.Body.Close() }()
+	w.Header().Set("Content-Type", "application/octet-stream")
+	w.Header().Set("Content-Length", fmtInt64(share.CiphertextSize))
+	w.WriteHeader(http.StatusOK)
+	_, _ = io.CopyN(w, resp.Body, share.CiphertextSize)
+}
+
+func fmtInt64(v int64) string {
+	return strconv.FormatInt(v, 10)
+}
diff --git a/orchestrator/internal/api/device_artifact_shares_test.go b/orchestrator/internal/api/device_artifact_shares_test.go
new file mode 100644
index 00000000..fa188b40
--- /dev/null
+++ b/orchestrator/internal/api/device_artifact_shares_test.go
@@ -0,0 +1,268 @@
+package api
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/cnjack/jcloud/internal/config"
+	"github.com/cnjack/jcloud/internal/domain"
+	"github.com/cnjack/jcloud/internal/sse"
+	"github.com/cnjack/jcloud/internal/store"
+)
+
+type artifactObjectFake struct {
+	mu       sync.Mutex
+	server   *httptest.Server
+	objects  map[string][]byte
+	statSize *int64
+}
+
+func newArtifactObjectFake(t *testing.T) *artifactObjectFake {
+	t.Helper()
+	fake := &artifactObjectFake{objects: make(map[string][]byte)}
+	fake.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		key := r.URL.Query().Get("key")
+		fake.mu.Lock()
+		defer fake.mu.Unlock()
+		switch r.Method {
+		case http.MethodPut:
+			body, err := io.ReadAll(r.Body)
+			if err != nil {
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			fake.objects[key] = body
+			w.WriteHeader(http.StatusNoContent)
+		case http.MethodGet:
+			body, ok := fake.objects[key]
+			if !ok {
+				w.WriteHeader(http.StatusNotFound)
+				return
+			}
+			w.Header().Set("Content-Type", "application/octet-stream")
+			_, _ = w.Write(body)
+		default:
+			w.WriteHeader(http.StatusMethodNotAllowed)
+		}
+	}))
+	t.Cleanup(fake.server.Close)
+	return fake
+}
+
+func (f *artifactObjectFake) PresignPut(key string, _ time.Duration) (string, error) {
+	return f.server.URL + "?key=" + url.QueryEscape(key), nil
+}
+func (f *artifactObjectFake) PresignGet(key string, _ time.Duration) (string, error) {
+	return f.server.URL + "?key=" + url.QueryEscape(key), nil
+}
+func (f *artifactObjectFake) Stat(_ context.Context, key string) (int64, string, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if f.statSize != nil {
+		return *f.statSize, "application/octet-stream", nil
+	}
+	return int64(len(f.objects[key])), "application/octet-stream", nil
+}
+func (f *artifactObjectFake) Delete(_ context.Context, key string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	delete(f.objects, key)
+	return nil
+}
+
+func artifactShareServer(t *testing.T) (*Server, *store.MemStore, *domain.User, *domain.Device, *artifactObjectFake) {
+	t.Helper()
+	st := store.NewMemStore()
+	srv := New(st, withTestModel(&config.Config{ConsoleToken: consoleToken, ConsoleURL: "https://cloud.example"}), slog.New(slog.NewTextHandler(io.Discard, nil)), sse.NewHub(), nil)
+	user := &domain.User{ID: "artifact-user", DisplayName: "Artifact User", CreatedAt: time.Now().UTC()}
+	identity := &domain.UserIdentity{ID: "artifact-identity", Provider: domain.ProviderGitHub, ProviderUID: "artifact-user", CreatedAt: time.Now().UTC()}
+	if _, err := st.CreateUserWithIdentity(t.Context(), user, identity); err != nil {
+		t.Fatal(err)
+	}
+	device := &domain.Device{ID: "artifact-device", UserID: user.ID, Name: "test", KeyGen: 1, CreatedAt: time.Now().UTC()}
+	if err := st.CreateDevice(t.Context(), device); err != nil {
+		t.Fatal(err)
+	}
+	objects := newArtifactObjectFake(t)
+	srv.WithAttachmentObjectStore(objects)
+	return srv, st, user, device, objects
+}
+
+func artifactDeviceRequest(t *testing.T, method, path string, body []byte, user *domain.User, device *domain.Device) *http.Request {
+	t.Helper()
+	r := httptest.NewRequest(method, path, bytes.NewReader(body))
+	r = r.WithContext(withPrincipal(r.Context(), &principal{deviceID: device.ID, deviceUserID: user.ID}))
+	return r
+}
+
+func TestDeviceArtifactShareLifecycleServesCiphertextOnlyUntilRevoked(t *testing.T) {
+	srv, _, user, device, _ := artifactShareServer(t)
+	content := bytes.Repeat([]byte{0xA5}, 32)
+	intentBody, _ := json.Marshal(map[string]any{
+		"protocol":    domain.ArtifactShareProtocolV1,
+		"artifact_id": "artifact-1", "revision": 2,
+		"ciphertext_size": len(content), "expires_in_seconds": 3600,
+	})
+	intentReq := artifactDeviceRequest(t, http.MethodPost, "/internal/v1/device/artifact-shares/intents", intentBody, user, device)
+	intentW := httptest.NewRecorder()
+	srv.handleCreateArtifactShareIntent(intentW, intentReq)
+	if intentW.Code != http.StatusCreated {
+		t.Fatalf("intent status=%d body=%s", intentW.Code, intentW.Body.String())
+	}
+	var intent struct {
+		ShareID     string `json:"share_id"`
+		UploadURL   string `json:"upload_url"`
+		CompleteURL string `json:"complete_url"`
+		BaseURL     string `json:"base_url"`
+	}
+	if err := json.Unmarshal(intentW.Body.Bytes(), &intent); err != nil {
+		t.Fatal(err)
+	}
+	if intent.ShareID == "" || intent.BaseURL != "https://cloud.example/s/"+intent.ShareID || bytes.Contains(intentW.Body.Bytes(), []byte("object_key")) {
+		t.Fatalf("intent response=%s", intentW.Body.String())
+	}
+
+	uploadReq := artifactDeviceRequest(t, http.MethodPut, intent.UploadURL, content, user, device)
+	uploadReq.SetPathValue("shareID", intent.ShareID)
+	uploadReq.ContentLength = int64(len(content))
+	uploadW := httptest.NewRecorder()
+	srv.handleUploadArtifactShareContent(uploadW, uploadReq)
+	if uploadW.Code != http.StatusNoContent {
+		t.Fatalf("upload status=%d body=%s", uploadW.Code, uploadW.Body.String())
+	}
+
+	digest := sha256.Sum256(content)
+	nonce := base64.RawURLEncoding.EncodeToString(bytes.Repeat([]byte{1}, 12))
+	metadataCiphertext := base64.RawURLEncoding.EncodeToString(bytes.Repeat([]byte{2}, 20))
+	completeBody, _ := json.Marshal(map[string]any{
+		"ciphertext_sha256":  hex.EncodeToString(digest[:]),
+		"encrypted_metadata": map[string]any{"nonce": nonce, "ciphertext": metadataCiphertext, "plaintext_length": 4},
+	})
+	completeReq := artifactDeviceRequest(t, http.MethodPost, intent.CompleteURL, completeBody, user, device)
+	completeReq.SetPathValue("shareID", intent.ShareID)
+	completeW := httptest.NewRecorder()
+	srv.handleCompleteArtifactShare(completeW, completeReq)
+	if completeW.Code != http.StatusOK {
+		t.Fatalf("complete status=%d body=%s", completeW.Code, completeW.Body.String())
+	}
+
+	metadataReq := httptest.NewRequest(http.MethodGet, "/api/v1/shared-artifacts/"+intent.ShareID, nil)
+	metadataReq.SetPathValue("shareID", intent.ShareID)
+	metadataW := httptest.NewRecorder()
+	srv.handleGetSharedArtifact(metadataW, metadataReq)
+	if metadataW.Code != http.StatusOK || !bytes.Contains(metadataW.Body.Bytes(), []byte(metadataCiphertext)) || bytes.Contains(metadataW.Body.Bytes(), []byte("artifact-user")) {
+		t.Fatalf("public metadata status=%d body=%s", metadataW.Code, metadataW.Body.String())
+	}
+	for header, want := range map[string]string{"Cache-Control": "no-store", "Referrer-Policy": "no-referrer", "X-Content-Type-Options": "nosniff"} {
+		if got := metadataW.Header().Get(header); got != want {
+			t.Fatalf("header %s=%q want %q", header, got, want)
+		}
+	}
+
+	contentReq := httptest.NewRequest(http.MethodGet, "/api/v1/shared-artifacts/"+intent.ShareID+"/content", nil)
+	contentReq.SetPathValue("shareID", intent.ShareID)
+	contentW := httptest.NewRecorder()
+	srv.handleGetSharedArtifactContent(contentW, contentReq)
+	if contentW.Code != http.StatusOK || !bytes.Equal(contentW.Body.Bytes(), content) || contentW.Header().Get("Location") != "" {
+		t.Fatalf("public content status=%d location=%q body=%x", contentW.Code, contentW.Header().Get("Location"), contentW.Body.Bytes())
+	}
+
+	revokeReq := artifactDeviceRequest(t, http.MethodDelete, "/internal/v1/device/artifact-shares/"+intent.ShareID, nil, user, device)
+	revokeReq.SetPathValue("shareID", intent.ShareID)
+	revokeW := httptest.NewRecorder()
+	srv.handleRevokeArtifactShare(revokeW, revokeReq)
+	if revokeW.Code != http.StatusNoContent {
+		t.Fatalf("revoke status=%d body=%s", revokeW.Code, revokeW.Body.String())
+	}
+	metadataW = httptest.NewRecorder()
+	srv.handleGetSharedArtifact(metadataW, metadataReq)
+	if metadataW.Code != http.StatusNotFound {
+		t.Fatalf("revoked public status=%d body=%s", metadataW.Code, metadataW.Body.String())
+	}
+}
+
+func TestDeviceArtifactShareIntentRejectsUnknownFieldsAndNonASCIIArtifactIDs(t *testing.T) {
+	srv, _, user, device, _ := artifactShareServer(t)
+	tests := []struct {
+		name string
+		body string
+	}{
+		{name: "strict json", body: `{"protocol":"jcode-artifact-share-v1","artifact_id":"artifact-1","revision":1,"ciphertext_size":32,"expires_in_seconds":3600,"plaintext_title":"leak"}`},
+		{name: "opaque ascii id", body: `{"protocol":"jcode-artifact-share-v1","artifact_id":"产物","revision":1,"ciphertext_size":32,"expires_in_seconds":3600}`},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req := artifactDeviceRequest(t, http.MethodPost, "/internal/v1/device/artifact-shares/intents", []byte(tt.body), user, device)
+			w := httptest.NewRecorder()
+			srv.handleCreateArtifactShareIntent(w, req)
+			if w.Code != http.StatusBadRequest {
+				t.Fatalf("status=%d body=%s", w.Code, w.Body.String())
+			}
+		})
+	}
+}
+
+func TestDeviceArtifactShareUploadRejectsStoredSizeMismatch(t *testing.T) {
+	srv, _, user, device, objects := artifactShareServer(t)
+	content := bytes.Repeat([]byte{0xA5}, 32)
+	intentBody := []byte(`{"protocol":"jcode-artifact-share-v1","artifact_id":"artifact-1","revision":1,"ciphertext_size":32,"expires_in_seconds":3600}`)
+	intentReq := artifactDeviceRequest(t, http.MethodPost, "/internal/v1/device/artifact-shares/intents", intentBody, user, device)
+	intentW := httptest.NewRecorder()
+	srv.handleCreateArtifactShareIntent(intentW, intentReq)
+	if intentW.Code != http.StatusCreated {
+		t.Fatalf("intent status=%d body=%s", intentW.Code, intentW.Body.String())
+	}
+	var intent struct {
+		ShareID   string `json:"share_id"`
+		UploadURL string `json:"upload_url"`
+	}
+	if err := json.Unmarshal(intentW.Body.Bytes(), &intent); err != nil {
+		t.Fatal(err)
+	}
+	wrongSize := int64(len(content) - 1)
+	objects.statSize = &wrongSize
+	uploadReq := artifactDeviceRequest(t, http.MethodPut, intent.UploadURL, content, user, device)
+	uploadReq.SetPathValue("shareID", intent.ShareID)
+	uploadReq.ContentLength = int64(len(content))
+	uploadW := httptest.NewRecorder()
+	srv.handleUploadArtifactShareContent(uploadW, uploadReq)
+	if uploadW.Code != http.StatusBadGateway {
+		t.Fatalf("upload status=%d body=%s", uploadW.Code, uploadW.Body.String())
+	}
+	objects.mu.Lock()
+	remaining := len(objects.objects)
+	objects.mu.Unlock()
+	if remaining != 0 {
+		t.Fatalf("mismatched object was not deleted: %d objects", remaining)
+	}
+}
+
+func TestArtifactShareRoutesKeepPublicReadUnauthenticatedAndDeviceWritesAuthenticated(t *testing.T) {
+	srv, _, _, _, _ := artifactShareServer(t)
+	h := srv.Handler()
+
+	publicW := httptest.NewRecorder()
+	h.ServeHTTP(publicW, httptest.NewRequest(http.MethodGet, "/api/v1/shared-artifacts/missing", nil))
+	if publicW.Code != http.StatusNotFound {
+		t.Fatalf("public status=%d body=%s", publicW.Code, publicW.Body.String())
+	}
+
+	intentW := httptest.NewRecorder()
+	h.ServeHTTP(intentW, httptest.NewRequest(http.MethodPost, "/internal/v1/device/artifact-shares/intents", strings.NewReader(`{}`)))
+	if intentW.Code != http.StatusUnauthorized {
+		t.Fatalf("intent status=%d body=%s", intentW.Code, intentW.Body.String())
+	}
+}
diff --git a/orchestrator/internal/domain/artifact_share.go b/orchestrator/internal/domain/artifact_share.go
new file mode 100644
index 00000000..1097f430
--- /dev/null
+++ b/orchestrator/internal/domain/artifact_share.go
@@ -0,0 +1,65 @@
+package domain
+
+import (
+	"strconv"
+	"time"
+)
+
+const (
+	ArtifactShareProtocolV1 = "jcode-artifact-share-v1"
+
+	ArtifactSharePending   = "pending"
+	ArtifactShareUploading = "uploading"
+	ArtifactShareUploaded  = "uploaded"
+	ArtifactShareComplete  = "complete"
+	ArtifactShareRevoked   = "revoked"
+)
+
+// EncryptedArtifactMetadata is an opaque AES-GCM envelope. Ciphertext includes
+// the 16-byte authentication tag; nonce and ciphertext use base64url without
+// padding. Cloud stores these fields but never decrypts them.
+type EncryptedArtifactMetadata struct {
+	Nonce           string `json:"nonce"`
+	Ciphertext      string `json:"ciphertext"`
+	PlaintextLength int64  `json:"plaintext_length"`
+}
+
+// ArtifactShare is one immutable, encrypted artifact snapshot. Content-bearing
+// fields are ciphertext only; local task ids, paths, titles and share keys are
+// deliberately absent.
+type ArtifactShare struct {
+	ID         string `json:"share_id"`
+	UserID     string `json:"-"`
+	DeviceID   string `json:"device_id,omitempty"`
+	ArtifactID string `json:"artifact_id"`
+	Revision   int    `json:"revision"`
+	Protocol   string `json:"protocol"`
+	State      string `json:"state"`
+
+	ObjectKey        string `json:"-"`
+	UploadGeneration int    `json:"-"`
+	UploadClaimID    string `json:"-"`
+	CiphertextSize   int64  `json:"ciphertext_size"`
+	CiphertextSHA256 string `json:"ciphertext_sha256,omitempty"`
+
+	EncryptedMetadata    *EncryptedArtifactMetadata `json:"encrypted_metadata,omitempty"`
+	IntentExpiresAt      time.Time                  `json:"-"`
+	UploadClaimedAt      *time.Time                 `json:"-"`
+	UploadLeaseExpiresAt *time.Time                 `json:"-"`
+	ExpiresAt            time.Time                  `json:"expires_at"`
+	UploadedAt           *time.Time                 `json:"uploaded_at,omitempty"`
+	CompletedAt          *time.Time                 `json:"completed_at,omitempty"`
+	RevokedAt            *time.Time                 `json:"revoked_at,omitempty"`
+	ObjectDeletedAt      *time.Time                 `json:"-"`
+	CreatedAt            time.Time                  `json:"created_at"`
+}
+
+// ObjectKeys returns every generation-specific object key that may need
+// deletion. Keys are deterministic and never serialized by an API.
+func (s ArtifactShare) ObjectKeys() []string {
+	keys := make([]string, 0, s.UploadGeneration)
+	for generation := 1; generation <= s.UploadGeneration; generation++ {
+		keys = append(keys, "artifact-shares/"+s.ID+"/"+strconv.Itoa(generation))
+	}
+	return keys
+}
diff --git a/orchestrator/internal/reconciler/reconciler.go b/orchestrator/internal/reconciler/reconciler.go
index c470dd14..9d235e0e 100644
--- a/orchestrator/internal/reconciler/reconciler.go
+++ b/orchestrator/internal/reconciler/reconciler.go
@@ -589,6 +589,26 @@ func (r *Reconciler) reconcileExpiredAttachmentStages(ctx context.Context) {
 			r.log.Warn("reconcile: delete expired attachment stage", "stage", stage.ID, "err", err)
 		}
 	}
+	shares, err := r.st.ListArtifactSharesForGC(ctx, now, attachmentCleanupBatchSize)
+	if err != nil {
+		r.log.Warn("reconcile: list artifact shares for gc", "err", err)
+		return
+	}
+	for _, share := range shares {
+		allDeleted := true
+		for _, key := range share.ObjectKeys() {
+			if err := r.attachmentStore.Delete(ctx, key); err != nil {
+				r.log.Warn("reconcile: delete artifact share object", "share", share.ID, "generation_key", key, "err", err)
+				allDeleted = false
+			}
+		}
+		if !allDeleted {
+			continue
+		}
+		if err := r.st.MarkArtifactShareObjectsDeleted(ctx, share.ID, now); err != nil && !errors.Is(err, store.ErrNotFound) {
+			r.log.Warn("reconcile: mark artifact share objects deleted", "share", share.ID, "err", err)
+		}
+	}
 	// Bindings deliberately survive run/project/user deletion until the backing
 	// object is removed. A shared retry/resume object is eligible only after its
 	// final live Run reference is gone.
diff --git a/orchestrator/internal/reconciler/reconciler_test.go b/orchestrator/internal/reconciler/reconciler_test.go
index b7f75e50..0906d1a8 100644
--- a/orchestrator/internal/reconciler/reconciler_test.go
+++ b/orchestrator/internal/reconciler/reconciler_test.go
@@ -7,6 +7,7 @@ import (
 	"errors"
 	"io"
 	"log/slog"
+	"reflect"
 	"strings"
 	"testing"
 	"time"
@@ -588,6 +589,38 @@ func TestTickReclaimsExpiredAttachmentOnlyAfterObjectDelete(t *testing.T) {
 	}
 }
 
+func TestTickReclaimsEveryExpiredArtifactShareGenerationBeforeMarkingDeleted(t *testing.T) {
+	ctx := context.Background()
+	rec, st, _ := testRec(t, 1)
+	now := time.Date(2026, time.July, 26, 12, 0, 0, 0, time.UTC)
+	rec.now = func() time.Time { return now }
+	rec.attachmentCleanupInterval = 0
+	share := &domain.ArtifactShare{
+		ID: "expired-share", UserID: "u", DeviceID: "d", ArtifactID: "a", Revision: 1,
+		Protocol: domain.ArtifactShareProtocolV1, State: domain.ArtifactShareUploaded,
+		CiphertextSize: 64, UploadGeneration: 2, ObjectKey: "artifact-shares/expired-share/2",
+		IntentExpiresAt: now.Add(-time.Minute), ExpiresAt: now.Add(time.Hour), CreatedAt: now.Add(-2 * time.Hour),
+	}
+	if err := st.CreateArtifactShare(ctx, share, 100, 1<<30); err != nil {
+		t.Fatal(err)
+	}
+	f := &fakeAttachmentStore{deleteErr: errors.New("s3 down")}
+	rec.attachmentStore = f
+	rec.Tick(ctx)
+	if candidates, err := st.ListArtifactSharesForGC(ctx, now, 10); err != nil || len(candidates) != 1 {
+		t.Fatalf("failed delete must retain GC candidate: %+v err=%v", candidates, err)
+	}
+	f.deleteErr = nil
+	rec.Tick(ctx)
+	if candidates, err := st.ListArtifactSharesForGC(ctx, now, 10); err != nil || len(candidates) != 0 {
+		t.Fatalf("successful delete must clear GC candidate: %+v err=%v", candidates, err)
+	}
+	want := []string{"artifact-shares/expired-share/1", "artifact-shares/expired-share/2", "artifact-shares/expired-share/1", "artifact-shares/expired-share/2"}
+	if !reflect.DeepEqual(f.deleted, want) {
+		t.Fatalf("delete attempts=%v want %v", f.deleted, want)
+	}
+}
+
 // TestCreateJobRetriesOnModelResolveError: a TRANSIENT model resolve error must
 // NOT permanently fail the run — the tick logs and skips (run stays queued, no
 // Job), and once the store recovers the next tick schedules it, consistent with
diff --git a/orchestrator/internal/store/artifact_shares_memory.go b/orchestrator/internal/store/artifact_shares_memory.go
new file mode 100644
index 00000000..9c9d7367
--- /dev/null
+++ b/orchestrator/internal/store/artifact_shares_memory.go
@@ -0,0 +1,223 @@
+package store
+
+import (
+	"context"
+	"sort"
+	"strconv"
+	"time"
+
+	"github.com/cnjack/jcloud/internal/domain"
+)
+
+const artifactShareMaxUploadGenerations = 3
+
+func cloneArtifactShare(in domain.ArtifactShare) domain.ArtifactShare {
+	out := in
+	if in.EncryptedMetadata != nil {
+		metadata := *in.EncryptedMetadata
+		out.EncryptedMetadata = &metadata
+	}
+	return out
+}
+
+func artifactShareActiveAt(share domain.ArtifactShare, at time.Time) bool {
+	if share.RevokedAt != nil || share.State == domain.ArtifactShareRevoked {
+		return false
+	}
+	if share.State == domain.ArtifactShareComplete {
+		return share.ExpiresAt.After(at)
+	}
+	return share.IntentExpiresAt.After(at)
+}
+
+func (m *MemStore) CreateArtifactShare(_ context.Context, share *domain.ArtifactShare, maxCount int, maxBytes int64) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if _, exists := m.artifactShares[share.ID]; exists {
+		return ErrAlreadyExists
+	}
+	var count int
+	var bytes int64
+	for _, existing := range m.artifactShares {
+		if existing.UserID == share.UserID && artifactShareActiveAt(existing, share.CreatedAt) {
+			count++
+			bytes += existing.CiphertextSize
+		}
+	}
+	if count >= maxCount || bytes+share.CiphertextSize > maxBytes {
+		return ErrArtifactShareQuotaExceeded
+	}
+	if share.State == "" {
+		share.State = domain.ArtifactSharePending
+	}
+	m.artifactShares[share.ID] = cloneArtifactShare(*share)
+	return nil
+}
+
+func (m *MemStore) ClaimArtifactShareUpload(_ context.Context, id, userID, claimID string, at, leaseExpiresAt time.Time) (*domain.ArtifactShare, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	share, ok := m.artifactShares[id]
+	if !ok {
+		return nil, ErrNotFound
+	}
+	claimable := share.State == domain.ArtifactSharePending ||
+		(share.State == domain.ArtifactShareUploading && share.UploadLeaseExpiresAt != nil && !share.UploadLeaseExpiresAt.After(at))
+	if share.UserID != userID || !claimable || !share.IntentExpiresAt.After(at) || share.UploadGeneration >= artifactShareMaxUploadGenerations {
+		return nil, ErrConflict
+	}
+	share.State = domain.ArtifactShareUploading
+	share.UploadGeneration++
+	share.UploadClaimID = claimID
+	share.ObjectKey = "artifact-shares/" + share.ID + "/" + strconv.Itoa(share.UploadGeneration)
+	share.UploadClaimedAt = timePtr(at)
+	share.UploadLeaseExpiresAt = timePtr(leaseExpiresAt)
+	m.artifactShares[id] = share
+	out := cloneArtifactShare(share)
+	return &out, nil
+}
+
+func (m *MemStore) MarkArtifactShareUploaded(_ context.Context, id, userID, claimID string, generation int, digest string, at time.Time) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	share, ok := m.artifactShares[id]
+	if !ok {
+		return ErrNotFound
+	}
+	if share.UserID != userID || share.State != domain.ArtifactShareUploading || share.UploadClaimID != claimID || share.UploadGeneration != generation || share.UploadLeaseExpiresAt == nil || !share.UploadLeaseExpiresAt.After(at) || !share.IntentExpiresAt.After(at) {
+		return ErrConflict
+	}
+	share.State = domain.ArtifactShareUploaded
+	share.CiphertextSHA256 = digest
+	share.UploadedAt = timePtr(at)
+	m.artifactShares[id] = share
+	return nil
+}
+
+func (m *MemStore) ReleaseArtifactShareUpload(_ context.Context, id, userID, claimID string, generation int) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	share, ok := m.artifactShares[id]
+	if !ok || share.UserID != userID || share.State != domain.ArtifactShareUploading || share.UploadClaimID != claimID || share.UploadGeneration != generation {
+		return false
+	}
+	share.State = domain.ArtifactSharePending
+	share.UploadClaimID = ""
+	share.UploadClaimedAt = nil
+	share.UploadLeaseExpiresAt = nil
+	m.artifactShares[id] = share
+	return true
+}
+
+func (m *MemStore) CompleteArtifactShare(_ context.Context, id, userID, digest string, metadata domain.EncryptedArtifactMetadata, at time.Time) (*domain.ArtifactShare, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	share, ok := m.artifactShares[id]
+	if !ok {
+		return nil, ErrNotFound
+	}
+	if share.UserID != userID {
+		return nil, ErrNotFound
+	}
+	if share.State == domain.ArtifactShareComplete {
+		if share.CiphertextSHA256 == digest && share.EncryptedMetadata != nil && *share.EncryptedMetadata == metadata {
+			out := cloneArtifactShare(share)
+			return &out, nil
+		}
+		return nil, ErrConflict
+	}
+	if share.State != domain.ArtifactShareUploaded || share.CiphertextSHA256 != digest || !share.IntentExpiresAt.After(at) {
+		return nil, ErrConflict
+	}
+	share.State = domain.ArtifactShareComplete
+	share.EncryptedMetadata = &metadata
+	share.CompletedAt = timePtr(at)
+	m.artifactShares[id] = share
+	out := cloneArtifactShare(share)
+	return &out, nil
+}
+
+func (m *MemStore) ListArtifactSharesForUser(_ context.Context, userID, artifactID string) ([]domain.ArtifactShare, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	out := make([]domain.ArtifactShare, 0)
+	for _, share := range m.artifactShares {
+		if share.UserID == userID && (artifactID == "" || share.ArtifactID == artifactID) {
+			out = append(out, cloneArtifactShare(share))
+		}
+	}
+	sort.Slice(out, func(i, j int) bool {
+		if out[i].CreatedAt.Equal(out[j].CreatedAt) {
+			return out[i].ID < out[j].ID
+		}
+		return out[i].CreatedAt.After(out[j].CreatedAt)
+	})
+	return out, nil
+}
+
+func (m *MemStore) GetPublicArtifactShare(_ context.Context, id string, at time.Time) (*domain.ArtifactShare, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	share, ok := m.artifactShares[id]
+	if !ok || share.State != domain.ArtifactShareComplete || share.RevokedAt != nil || !share.ExpiresAt.After(at) {
+		return nil, ErrNotFound
+	}
+	out := cloneArtifactShare(share)
+	return &out, nil
+}
+
+func (m *MemStore) RevokeArtifactShare(_ context.Context, id, userID string, at time.Time) (*domain.ArtifactShare, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	share, ok := m.artifactShares[id]
+	if !ok || share.UserID != userID {
+		return nil, ErrNotFound
+	}
+	if share.RevokedAt == nil {
+		share.State = domain.ArtifactShareRevoked
+		share.RevokedAt = timePtr(at)
+		m.artifactShares[id] = share
+	}
+	out := cloneArtifactShare(share)
+	return &out, nil
+}
+
+func (m *MemStore) ListArtifactSharesForGC(_ context.Context, before time.Time, limit int) ([]domain.ArtifactShare, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if limit <= 0 {
+		limit = 100
+	}
+	out := make([]domain.ArtifactShare, 0, limit)
+	for _, share := range m.artifactShares {
+		if share.ObjectDeletedAt != nil {
+			continue
+		}
+		expiredIntent := share.State != domain.ArtifactShareComplete && !share.IntentExpiresAt.After(before)
+		expiredShare := share.State == domain.ArtifactShareComplete && !share.ExpiresAt.After(before)
+		if share.RevokedAt != nil || expiredIntent || expiredShare {
+			out = append(out, cloneArtifactShare(share))
+		}
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].CreatedAt.Before(out[j].CreatedAt) })
+	if len(out) > limit {
+		out = out[:limit]
+	}
+	return out, nil
+}
+
+func (m *MemStore) MarkArtifactShareObjectsDeleted(_ context.Context, id string, at time.Time) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	share, ok := m.artifactShares[id]
+	if !ok {
+		return ErrNotFound
+	}
+	if share.ObjectDeletedAt == nil {
+		share.ObjectDeletedAt = timePtr(at)
+		m.artifactShares[id] = share
+	}
+	return nil
+}
+
+func timePtr(t time.Time) *time.Time { return &t }
diff --git a/orchestrator/internal/store/artifact_shares_pg.go b/orchestrator/internal/store/artifact_shares_pg.go
new file mode 100644
index 00000000..5030a199
--- /dev/null
+++ b/orchestrator/internal/store/artifact_shares_pg.go
@@ -0,0 +1,210 @@
+package store
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+
+	"github.com/cnjack/jcloud/internal/domain"
+)
+
+const artifactShareCols = `id,user_id,COALESCE(device_id,''),artifact_id,revision,protocol,state,
+	COALESCE(object_key,''),upload_generation,COALESCE(upload_claim_id,''),ciphertext_size,COALESCE(ciphertext_sha256,''),
+	encrypted_metadata,intent_expires_at,upload_claimed_at,upload_lease_expires_at,expires_at,uploaded_at,completed_at,
+	revoked_at,object_deleted_at,created_at`
+
+func scanArtifactShare(row pgx.Row) (*domain.ArtifactShare, error) {
+	var share domain.ArtifactShare
+	var metadata []byte
+	err := row.Scan(
+		&share.ID, &share.UserID, &share.DeviceID, &share.ArtifactID, &share.Revision, &share.Protocol, &share.State,
+		&share.ObjectKey, &share.UploadGeneration, &share.UploadClaimID, &share.CiphertextSize, &share.CiphertextSHA256,
+		&metadata, &share.IntentExpiresAt, &share.UploadClaimedAt, &share.UploadLeaseExpiresAt, &share.ExpiresAt,
+		&share.UploadedAt, &share.CompletedAt, &share.RevokedAt, &share.ObjectDeletedAt, &share.CreatedAt,
+	)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		return nil, fmt.Errorf("scan artifact share: %w", err)
+	}
+	if len(metadata) > 0 {
+		var envelope domain.EncryptedArtifactMetadata
+		if err := json.Unmarshal(metadata, &envelope); err != nil {
+			return nil, fmt.Errorf("scan artifact share metadata: %w", err)
+		}
+		share.EncryptedMetadata = &envelope
+	}
+	return &share, nil
+}
+
+func (s *PGStore) CreateArtifactShare(ctx context.Context, share *domain.ArtifactShare, maxCount int, maxBytes int64) error {
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return fmt.Errorf("create artifact share: begin: %w", err)
+	}
+	defer tx.Rollback(ctx) //nolint:errcheck
+	if _, err := tx.Exec(ctx, `SELECT pg_advisory_xact_lock(hashtextextended('artifact-share:' || $1, 0))`, share.UserID); err != nil {
+		return fmt.Errorf("create artifact share: quota lock: %w", err)
+	}
+	var count int
+	var bytes int64
+	if err := tx.QueryRow(ctx, `SELECT count(*),COALESCE(sum(ciphertext_size),0)
+		FROM device_artifact_shares
+		WHERE user_id=$1 AND revoked_at IS NULL AND
+		((state='complete' AND expires_at>$2) OR (state<>'complete' AND intent_expires_at>$2))`,
+		share.UserID, share.CreatedAt).Scan(&count, &bytes); err != nil {
+		return fmt.Errorf("create artifact share: quota read: %w", err)
+	}
+	if count >= maxCount || bytes+share.CiphertextSize > maxBytes {
+		return ErrArtifactShareQuotaExceeded
+	}
+	_, err = tx.Exec(ctx, `INSERT INTO device_artifact_shares(
+		id,user_id,device_id,artifact_id,revision,protocol,state,ciphertext_size,intent_expires_at,expires_at,created_at)
+		VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)`, share.ID, share.UserID, nullStr(share.DeviceID),
+		share.ArtifactID, share.Revision, share.Protocol, share.State, share.CiphertextSize,
+		share.IntentExpiresAt, share.ExpiresAt, share.CreatedAt)
+	if err != nil {
+		if isUniqueViolation(err) {
+			return ErrAlreadyExists
+		}
+		return fmt.Errorf("create artifact share: %w", err)
+	}
+	if err := tx.Commit(ctx); err != nil {
+		return fmt.Errorf("create artifact share: commit: %w", err)
+	}
+	return nil
+}
+
+func (s *PGStore) ClaimArtifactShareUpload(ctx context.Context, id, userID, claimID string, at, leaseExpiresAt time.Time) (*domain.ArtifactShare, error) {
+	return scanArtifactShare(s.pool.QueryRow(ctx, `UPDATE device_artifact_shares SET
+		state='uploading', upload_generation=upload_generation+1, upload_claim_id=$3,
+		object_key='artifact-shares/' || id || '/' || (upload_generation+1)::text,
+		upload_claimed_at=$4, upload_lease_expires_at=$5
+		WHERE id=$1 AND user_id=$2 AND intent_expires_at>$4 AND upload_generation<3 AND
+		(state='pending' OR (state='uploading' AND upload_lease_expires_at<=$4))
+		RETURNING `+artifactShareCols, id, userID, claimID, at, leaseExpiresAt))
+}
+
+func (s *PGStore) MarkArtifactShareUploaded(ctx context.Context, id, userID, claimID string, generation int, digest string, at time.Time) error {
+	tag, err := s.pool.Exec(ctx, `UPDATE device_artifact_shares SET state='uploaded',ciphertext_sha256=$5,uploaded_at=$6
+		WHERE id=$1 AND user_id=$2 AND state='uploading' AND upload_claim_id=$3 AND upload_generation=$4
+		AND upload_lease_expires_at>$6 AND intent_expires_at>$6`, id, userID, claimID, generation, digest, at)
+	if err != nil {
+		return fmt.Errorf("mark artifact share uploaded: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrConflict
+	}
+	return nil
+}
+
+func (s *PGStore) ReleaseArtifactShareUpload(ctx context.Context, id, userID, claimID string, generation int) bool {
+	tag, err := s.pool.Exec(ctx, `UPDATE device_artifact_shares SET state='pending',upload_claim_id=NULL,
+		upload_claimed_at=NULL,upload_lease_expires_at=NULL
+		WHERE id=$1 AND user_id=$2 AND state='uploading' AND upload_claim_id=$3 AND upload_generation=$4`,
+		id, userID, claimID, generation)
+	return err == nil && tag.RowsAffected() == 1
+}
+
+func (s *PGStore) CompleteArtifactShare(ctx context.Context, id, userID, digest string, metadata domain.EncryptedArtifactMetadata, at time.Time) (*domain.ArtifactShare, error) {
+	encoded, err := json.Marshal(metadata)
+	if err != nil {
+		return nil, fmt.Errorf("complete artifact share metadata: %w", err)
+	}
+	share, err := scanArtifactShare(s.pool.QueryRow(ctx, `UPDATE device_artifact_shares SET
+		state='complete',encrypted_metadata=$4,completed_at=$5
+		WHERE id=$1 AND user_id=$2 AND state='uploaded' AND ciphertext_sha256=$3 AND intent_expires_at>$5
+		RETURNING `+artifactShareCols, id, userID, digest, encoded, at))
+	if err == nil {
+		return share, nil
+	}
+	if !errors.Is(err, ErrNotFound) {
+		return nil, err
+	}
+	existing, err := s.getArtifactShareForUser(ctx, id, userID)
+	if err != nil {
+		return nil, err
+	}
+	if existing.State == domain.ArtifactShareComplete && existing.CiphertextSHA256 == digest && existing.EncryptedMetadata != nil && *existing.EncryptedMetadata == metadata {
+		return existing, nil
+	}
+	return nil, ErrConflict
+}
+
+func (s *PGStore) getArtifactShareForUser(ctx context.Context, id, userID string) (*domain.ArtifactShare, error) {
+	return scanArtifactShare(s.pool.QueryRow(ctx, `SELECT `+artifactShareCols+` FROM device_artifact_shares WHERE id=$1 AND user_id=$2`, id, userID))
+}
+
+func (s *PGStore) ListArtifactSharesForUser(ctx context.Context, userID, artifactID string) ([]domain.ArtifactShare, error) {
+	query := `SELECT ` + artifactShareCols + ` FROM device_artifact_shares WHERE user_id=$1`
+	args := []any{userID}
+	if artifactID != "" {
+		query += ` AND artifact_id=$2`
+		args = append(args, artifactID)
+	}
+	query += ` ORDER BY created_at DESC,id`
+	rows, err := s.pool.Query(ctx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("list artifact shares: %w", err)
+	}
+	defer rows.Close()
+	var out []domain.ArtifactShare
+	for rows.Next() {
+		share, err := scanArtifactShare(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, *share)
+	}
+	return out, rows.Err()
+}
+
+func (s *PGStore) GetPublicArtifactShare(ctx context.Context, id string, at time.Time) (*domain.ArtifactShare, error) {
+	return scanArtifactShare(s.pool.QueryRow(ctx, `SELECT `+artifactShareCols+` FROM device_artifact_shares
+		WHERE id=$1 AND state='complete' AND revoked_at IS NULL AND expires_at>$2`, id, at))
+}
+
+func (s *PGStore) RevokeArtifactShare(ctx context.Context, id, userID string, at time.Time) (*domain.ArtifactShare, error) {
+	return scanArtifactShare(s.pool.QueryRow(ctx, `UPDATE device_artifact_shares SET
+		state='revoked',revoked_at=COALESCE(revoked_at,$3)
+		WHERE id=$1 AND user_id=$2 RETURNING `+artifactShareCols, id, userID, at))
+}
+
+func (s *PGStore) ListArtifactSharesForGC(ctx context.Context, before time.Time, limit int) ([]domain.ArtifactShare, error) {
+	if limit <= 0 {
+		limit = 100
+	}
+	rows, err := s.pool.Query(ctx, `SELECT `+artifactShareCols+` FROM device_artifact_shares
+		WHERE object_deleted_at IS NULL AND (revoked_at IS NOT NULL OR
+		(state='complete' AND expires_at<=$1) OR (state<>'complete' AND intent_expires_at<=$1))
+		ORDER BY created_at,id LIMIT $2`, before, limit)
+	if err != nil {
+		return nil, fmt.Errorf("list artifact shares for gc: %w", err)
+	}
+	defer rows.Close()
+	var out []domain.ArtifactShare
+	for rows.Next() {
+		share, err := scanArtifactShare(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, *share)
+	}
+	return out, rows.Err()
+}
+
+func (s *PGStore) MarkArtifactShareObjectsDeleted(ctx context.Context, id string, at time.Time) error {
+	tag, err := s.pool.Exec(ctx, `UPDATE device_artifact_shares SET object_deleted_at=COALESCE(object_deleted_at,$2) WHERE id=$1`, id, at)
+	if err != nil {
+		return fmt.Errorf("mark artifact share objects deleted: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
diff --git a/orchestrator/internal/store/artifact_shares_test.go b/orchestrator/internal/store/artifact_shares_test.go
new file mode 100644
index 00000000..83e20f86
--- /dev/null
+++ b/orchestrator/internal/store/artifact_shares_test.go
@@ -0,0 +1,225 @@
+package store
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/cnjack/jcloud/internal/domain"
+)
+
+func TestMemArtifactShareLeaseTakeoverKeepsObjectAndDigestGenerationBound(t *testing.T) {
+	ctx := context.Background()
+	st := NewMemStore()
+	now := time.Date(2026, 8, 1, 12, 0, 0, 0, time.UTC)
+	share := &domain.ArtifactShare{
+		ID: "share-1", UserID: "user-1", DeviceID: "device-1",
+		ArtifactID: "artifact-1", Revision: 3, Protocol: domain.ArtifactShareProtocolV1,
+		State: domain.ArtifactSharePending, CiphertextSize: 128,
+		IntentExpiresAt: now.Add(time.Hour), ExpiresAt: now.Add(7 * 24 * time.Hour), CreatedAt: now,
+	}
+	if err := st.CreateArtifactShare(ctx, share, 100, 1<<30); err != nil {
+		t.Fatal(err)
+	}
+
+	first, err := st.ClaimArtifactShareUpload(ctx, share.ID, share.UserID, "claim-1", now, now.Add(5*time.Minute))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if first.UploadGeneration != 1 || !strings.HasSuffix(first.ObjectKey, "/1") {
+		t.Fatalf("first claim=%+v", first)
+	}
+	if _, err := st.ClaimArtifactShareUpload(ctx, share.ID, share.UserID, "claim-early", now.Add(time.Minute), now.Add(6*time.Minute)); !errors.Is(err, ErrConflict) {
+		t.Fatalf("active lease claim err=%v want conflict", err)
+	}
+
+	second, err := st.ClaimArtifactShareUpload(ctx, share.ID, share.UserID, "claim-2", now.Add(6*time.Minute), now.Add(11*time.Minute))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if second.UploadGeneration != 2 || second.ObjectKey == first.ObjectKey || !strings.HasSuffix(second.ObjectKey, "/2") {
+		t.Fatalf("takeover=%+v first_key=%q", second, first.ObjectKey)
+	}
+	if err := st.MarkArtifactShareUploaded(ctx, share.ID, share.UserID, "claim-1", 1, "old-digest", now.Add(7*time.Minute)); !errors.Is(err, ErrConflict) {
+		t.Fatalf("late old upload err=%v want conflict", err)
+	}
+	if err := st.MarkArtifactShareUploaded(ctx, share.ID, share.UserID, "claim-2", 2, "new-digest", now.Add(7*time.Minute)); err != nil {
+		t.Fatal(err)
+	}
+
+	metadata := domain.EncryptedArtifactMetadata{Nonce: "nonce", Ciphertext: "ciphertext", PlaintextLength: 32}
+	if _, err := st.CompleteArtifactShare(ctx, share.ID, share.UserID, "old-digest", metadata, now.Add(8*time.Minute)); !errors.Is(err, ErrConflict) {
+		t.Fatalf("wrong digest complete err=%v want conflict", err)
+	}
+	completed, err := st.CompleteArtifactShare(ctx, share.ID, share.UserID, "new-digest", metadata, now.Add(8*time.Minute))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if completed.State != domain.ArtifactShareComplete || completed.ObjectKey != second.ObjectKey || completed.CiphertextSHA256 != "new-digest" {
+		t.Fatalf("completed=%+v", completed)
+	}
+	public, err := st.GetPublicArtifactShare(ctx, share.ID, now.Add(9*time.Minute))
+	if err != nil || public.State != domain.ArtifactShareComplete {
+		t.Fatalf("public=%+v err=%v", public, err)
+	}
+}
+
+func TestMemArtifactShareRevokeMakesPublicReadDisappearAndQueuesEveryGenerationForGC(t *testing.T) {
+	ctx := context.Background()
+	st := NewMemStore()
+	now := time.Date(2026, 8, 1, 12, 0, 0, 0, time.UTC)
+	share := &domain.ArtifactShare{
+		ID: "share-revoke", UserID: "user-1", DeviceID: "device-1",
+		ArtifactID: "artifact-1", Revision: 1, Protocol: domain.ArtifactShareProtocolV1,
+		State: domain.ArtifactSharePending, CiphertextSize: 64,
+		IntentExpiresAt: now.Add(time.Hour), ExpiresAt: now.Add(24 * time.Hour), CreatedAt: now,
+	}
+	if err := st.CreateArtifactShare(ctx, share, 100, 1<<30); err != nil {
+		t.Fatal(err)
+	}
+	first, err := st.ClaimArtifactShareUpload(ctx, share.ID, share.UserID, "claim-1", now, now.Add(time.Minute))
+	if err != nil {
+		t.Fatal(err)
+	}
+	second, err := st.ClaimArtifactShareUpload(ctx, share.ID, share.UserID, "claim-2", now.Add(2*time.Minute), now.Add(7*time.Minute))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := st.MarkArtifactShareUploaded(ctx, share.ID, share.UserID, "claim-2", second.UploadGeneration, "digest", now.Add(3*time.Minute)); err != nil {
+		t.Fatal(err)
+	}
+	metadata := domain.EncryptedArtifactMetadata{Nonce: "nonce", Ciphertext: "ciphertext", PlaintextLength: 4}
+	if _, err := st.CompleteArtifactShare(ctx, share.ID, share.UserID, "digest", metadata, now.Add(4*time.Minute)); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := st.RevokeArtifactShare(ctx, share.ID, share.UserID, now.Add(5*time.Minute)); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := st.RevokeArtifactShare(ctx, share.ID, share.UserID, now.Add(6*time.Minute)); err != nil {
+		t.Fatalf("repeat revoke must be idempotent: %v", err)
+	}
+	if _, err := st.GetPublicArtifactShare(ctx, share.ID, now.Add(6*time.Minute)); !errors.Is(err, ErrNotFound) {
+		t.Fatalf("revoked public read err=%v want not found", err)
+	}
+	candidates, err := st.ListArtifactSharesForGC(ctx, now.Add(6*time.Minute), 10)
+	if err != nil || len(candidates) != 1 {
+		t.Fatalf("gc candidates=%+v err=%v", candidates, err)
+	}
+	keys := candidates[0].ObjectKeys()
+	if len(keys) != 2 || keys[0] != first.ObjectKey || keys[1] != second.ObjectKey {
+		t.Fatalf("generation keys=%v", keys)
+	}
+	if err := st.MarkArtifactShareObjectsDeleted(ctx, share.ID, now.Add(7*time.Minute)); err != nil {
+		t.Fatal(err)
+	}
+	candidates, err = st.ListArtifactSharesForGC(ctx, now.Add(8*time.Minute), 10)
+	if err != nil || len(candidates) != 0 {
+		t.Fatalf("deleted candidates=%+v err=%v", candidates, err)
+	}
+}
+
+func TestMemArtifactShareQuotaCountsOnlyActiveReservations(t *testing.T) {
+	ctx := context.Background()
+	st := NewMemStore()
+	now := time.Date(2026, 8, 1, 12, 0, 0, 0, time.UTC)
+	newShare := func(id string, size int64, intentExpiry time.Time) *domain.ArtifactShare {
+		return &domain.ArtifactShare{
+			ID: id, UserID: "quota-user", ArtifactID: "artifact-" + id, Revision: 1,
+			Protocol: domain.ArtifactShareProtocolV1, State: domain.ArtifactSharePending,
+			CiphertextSize: size, IntentExpiresAt: intentExpiry, ExpiresAt: now.Add(24 * time.Hour), CreatedAt: now,
+		}
+	}
+	if err := st.CreateArtifactShare(ctx, newShare("active", 60, now.Add(time.Hour)), 2, 100); err != nil {
+		t.Fatal(err)
+	}
+	if err := st.CreateArtifactShare(ctx, newShare("bytes-over", 41, now.Add(time.Hour)), 2, 100); !errors.Is(err, ErrArtifactShareQuotaExceeded) {
+		t.Fatalf("bytes quota err=%v", err)
+	}
+	if _, err := st.RevokeArtifactShare(ctx, "active", "quota-user", now.Add(time.Minute)); err != nil {
+		t.Fatal(err)
+	}
+	if err := st.CreateArtifactShare(ctx, newShare("after-revoke", 100, now.Add(time.Hour)), 2, 100); err != nil {
+		t.Fatalf("revoked reservation should release quota: %v", err)
+	}
+	if err := st.CreateArtifactShare(ctx, newShare("count-over", 1, now.Add(time.Hour)), 1, 1000); !errors.Is(err, ErrArtifactShareQuotaExceeded) {
+		t.Fatalf("count quota err=%v", err)
+	}
+	expiredStore := NewMemStore()
+	if err := expiredStore.CreateArtifactShare(ctx, newShare("already-expired", 1000, now.Add(-time.Minute)), 10, 2000); err != nil {
+		t.Fatal(err)
+	}
+	if err := expiredStore.CreateArtifactShare(ctx, newShare("after-expiry", 100, now.Add(time.Hour)), 10, 100); err != nil {
+		t.Fatalf("an expired intent must not reserve active bytes: %v", err)
+	}
+}
+
+func TestMemArtifactShareUploadRetryIsBoundedToThreeGenerations(t *testing.T) {
+	ctx := context.Background()
+	st := NewMemStore()
+	now := time.Date(2026, 8, 1, 12, 0, 0, 0, time.UTC)
+	share := &domain.ArtifactShare{
+		ID: "share-retries", UserID: "user-1", ArtifactID: "artifact-1", Revision: 1,
+		Protocol: domain.ArtifactShareProtocolV1, State: domain.ArtifactSharePending, CiphertextSize: 64,
+		IntentExpiresAt: now.Add(time.Hour), ExpiresAt: now.Add(24 * time.Hour), CreatedAt: now,
+	}
+	if err := st.CreateArtifactShare(ctx, share, 100, 1<<30); err != nil {
+		t.Fatal(err)
+	}
+	for generation := 1; generation <= 3; generation++ {
+		at := now.Add(time.Duration(generation-1) * 2 * time.Minute)
+		claimed, err := st.ClaimArtifactShareUpload(ctx, share.ID, share.UserID, "claim-"+string(rune('0'+generation)), at, at.Add(time.Minute))
+		if err != nil || claimed.UploadGeneration != generation {
+			t.Fatalf("generation=%d claimed=%+v err=%v", generation, claimed, err)
+		}
+	}
+	if _, err := st.ClaimArtifactShareUpload(ctx, share.ID, share.UserID, "claim-4", now.Add(7*time.Minute), now.Add(8*time.Minute)); !errors.Is(err, ErrConflict) {
+		t.Fatalf("fourth generation err=%v want conflict", err)
+	}
+}
+
+func TestPGArtifactShareLifecycleMatchesMemoryStore(t *testing.T) {
+	ctx := context.Background()
+	st, _ := pgTestStore(t)
+	now := time.Now().UTC()
+	user := &domain.User{ID: domain.NewID(), DisplayName: "Artifact Share Test", CreatedAt: now}
+	identity := &domain.UserIdentity{ID: domain.NewID(), Provider: domain.ProviderGitHub, ProviderUID: "artifact-share-" + user.ID, CreatedAt: now}
+	if _, err := st.CreateUserWithIdentity(ctx, user, identity); err != nil {
+		t.Fatal(err)
+	}
+	device := &domain.Device{ID: domain.NewID(), UserID: user.ID, Name: "test", KeyGen: 1, CreatedAt: now}
+	if err := st.CreateDevice(ctx, device); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		_, _ = st.Pool().Exec(ctx, `DELETE FROM device_artifact_shares WHERE user_id=$1`, user.ID)
+		_, _ = st.Pool().Exec(ctx, `DELETE FROM users WHERE id=$1`, user.ID)
+	})
+
+	share := &domain.ArtifactShare{
+		ID: domain.NewID(), UserID: user.ID, DeviceID: device.ID,
+		ArtifactID: "artifact-pg", Revision: 2, Protocol: domain.ArtifactShareProtocolV1,
+		State: domain.ArtifactSharePending, CiphertextSize: 64,
+		IntentExpiresAt: now.Add(time.Hour), ExpiresAt: now.Add(24 * time.Hour), CreatedAt: now,
+	}
+	if err := st.CreateArtifactShare(ctx, share, 100, 1<<30); err != nil {
+		t.Fatal(err)
+	}
+	claim, err := st.ClaimArtifactShareUpload(ctx, share.ID, user.ID, "claim-pg", now, now.Add(5*time.Minute))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := st.MarkArtifactShareUploaded(ctx, share.ID, user.ID, "claim-pg", claim.UploadGeneration, "digest-pg", now.Add(time.Minute)); err != nil {
+		t.Fatal(err)
+	}
+	metadata := domain.EncryptedArtifactMetadata{Nonce: "nonce", Ciphertext: "ciphertext", PlaintextLength: 7}
+	completed, err := st.CompleteArtifactShare(ctx, share.ID, user.ID, "digest-pg", metadata, now.Add(2*time.Minute))
+	if err != nil || completed.State != domain.ArtifactShareComplete {
+		t.Fatalf("completed=%+v err=%v", completed, err)
+	}
+	public, err := st.GetPublicArtifactShare(ctx, share.ID, now.Add(3*time.Minute))
+	if err != nil || public.EncryptedMetadata == nil || *public.EncryptedMetadata != metadata {
+		t.Fatalf("public=%+v err=%v", public, err)
+	}
+}
diff --git a/orchestrator/internal/store/memory.go b/orchestrator/internal/store/memory.go
index 8af3c2e2..ea151fc1 100644
--- a/orchestrator/internal/store/memory.go
+++ b/orchestrator/internal/store/memory.go
@@ -73,6 +73,7 @@ type MemStore struct {
 	deviceCommands           map[string]domain.DeviceCommand         // keyed by command id
 	devicePairings           map[string]domain.DevicePairing         // keyed by pairing id
 	deviceOffers             map[string]domain.DevicePairingOffer    // keyed by offer id
+	artifactShares           map[string]domain.ArtifactShare         // keyed by share id
 	attachmentStages         map[string]domain.AttachmentStage
 	runAttachments           map[string][]domain.RunAttachment
 	usageEvents              map[string]domain.UsageEvent // keyed by request id
@@ -137,6 +138,7 @@ func NewMemStore() *MemStore {
 		deviceCommands:           map[string]domain.DeviceCommand{},
 		devicePairings:           map[string]domain.DevicePairing{},
 		deviceOffers:             map[string]domain.DevicePairingOffer{},
+		artifactShares:           map[string]domain.ArtifactShare{},
 		attachmentStages:         map[string]domain.AttachmentStage{},
 		runAttachments:           map[string][]domain.RunAttachment{},
 		usageEvents:              map[string]domain.UsageEvent{},
diff --git a/orchestrator/internal/store/migrate_test.go b/orchestrator/internal/store/migrate_test.go
index 1112011b..e0754aa6 100644
--- a/orchestrator/internal/store/migrate_test.go
+++ b/orchestrator/internal/store/migrate_test.go
@@ -240,6 +240,32 @@ func TestProviderScopedModelNamesMigrationContract(t *testing.T) {
 	}
 }
 
+func TestArtifactShareMigrationKeepsCiphertextLifecycleBoundedAndUserOwned(t *testing.T) {
+	sql, err := migrationsFS.ReadFile("migrations/0071_device_artifact_shares.sql")
+	if err != nil {
+		t.Fatal(err)
+	}
+	migration := strings.Join(strings.Fields(string(sql)), " ")
+	for _, required := range []string{
+		"CREATE TABLE IF NOT EXISTS device_artifact_shares",
+		"user_id TEXT NOT NULL REFERENCES users(id) ON DELETE RESTRICT",
+		"device_id TEXT REFERENCES devices(id) ON DELETE SET NULL",
+		"CHECK (protocol = 'jcode-artifact-share-v1')",
+		"CHECK (upload_generation BETWEEN 0 AND 3)",
+		"encrypted_metadata JSONB",
+		"object_deleted_at TIMESTAMPTZ",
+	} {
+		if !strings.Contains(migration, required) {
+			t.Fatalf("0071 migration missing %q", required)
+		}
+	}
+	for _, forbidden := range []string{"share_key", "plaintext", "title TEXT", "relative_path"} {
+		if strings.Contains(migration, forbidden) {
+			t.Fatalf("0071 migration must not persist %q", forbidden)
+		}
+	}
+}
+
 func TestDesktopConfigMeshMigrationContract(t *testing.T) {
 	sql, err := migrationsFS.ReadFile("migrations/0039_desktop_config_mesh.sql")
 	if err != nil {
diff --git a/orchestrator/internal/store/migrations/0071_device_artifact_shares.sql b/orchestrator/internal/store/migrations/0071_device_artifact_shares.sql
new file mode 100644
index 00000000..fdab7e4d
--- /dev/null
+++ b/orchestrator/internal/store/migrations/0071_device_artifact_shares.sql
@@ -0,0 +1,38 @@
+-- 0071_device_artifact_shares.sql
+--
+-- Immutable, end-to-end encrypted Artifact snapshots uploaded by an
+-- authenticated jcode device. Cloud stores routing/lifecycle data and
+-- ciphertext only; the decryption key remains in the URL fragment.
+
+CREATE TABLE IF NOT EXISTS device_artifact_shares (
+    id                      TEXT PRIMARY KEY,
+    -- Keep lifecycle rows until their object generations have been erased.
+    -- Account deletion must revoke/GC shares first instead of orphaning blobs.
+    user_id                 TEXT NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
+    device_id               TEXT REFERENCES devices(id) ON DELETE SET NULL,
+    artifact_id             TEXT NOT NULL,
+    revision                INT NOT NULL CHECK (revision > 0),
+    protocol                TEXT NOT NULL CHECK (protocol = 'jcode-artifact-share-v1'),
+    state                   TEXT NOT NULL DEFAULT 'pending'
+                                CHECK (state IN ('pending','uploading','uploaded','complete','revoked')),
+    object_key              TEXT UNIQUE,
+    upload_generation       INT NOT NULL DEFAULT 0 CHECK (upload_generation BETWEEN 0 AND 3),
+    upload_claim_id         TEXT,
+    ciphertext_size         BIGINT NOT NULL CHECK (ciphertext_size >= 28),
+    ciphertext_sha256       TEXT,
+    encrypted_metadata      JSONB,
+    intent_expires_at       TIMESTAMPTZ NOT NULL,
+    upload_claimed_at       TIMESTAMPTZ,
+    upload_lease_expires_at TIMESTAMPTZ,
+    expires_at              TIMESTAMPTZ NOT NULL,
+    uploaded_at             TIMESTAMPTZ,
+    completed_at            TIMESTAMPTZ,
+    revoked_at              TIMESTAMPTZ,
+    object_deleted_at       TIMESTAMPTZ,
+    created_at              TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX IF NOT EXISTS device_artifact_shares_user_artifact_idx
+    ON device_artifact_shares (user_id, artifact_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS device_artifact_shares_gc_idx
+    ON device_artifact_shares (object_deleted_at, revoked_at, intent_expires_at, expires_at);
diff --git a/orchestrator/internal/store/store.go b/orchestrator/internal/store/store.go
index 5086f11e..d8e712ec 100644
--- a/orchestrator/internal/store/store.go
+++ b/orchestrator/internal/store/store.go
@@ -33,6 +33,10 @@ var ErrConflict = errors.New("conflict")
 // too many or too many bytes of unconsumed staged uploads.
 var ErrAttachmentQuotaExceeded = errors.New("attachment staging quota exceeded")
 
+// ErrArtifactShareQuotaExceeded is returned atomically when a user has too
+// many active encrypted shares or too many reserved ciphertext bytes.
+var ErrArtifactShareQuotaExceeded = errors.New("artifact share quota exceeded")
+
 // ErrDispatchClaimUnavailable means a queued run could not atomically reserve
 // the Plugin set it needs for launch (disabled, revoked, or reconfigured).
 var ErrDispatchClaimUnavailable = errors.New("dispatch claim unavailable")
@@ -926,6 +930,20 @@ type Store interface {
 	// (the "my devices" client view).
 	ListDevicesForUser(ctx context.Context, userID string) ([]domain.Device, error)
 
+	// --- Encrypted Artifact shares ------------------------------------------
+	// The JSON metadata envelope and object body are ciphertext. These methods
+	// own the intent/upload/complete lifecycle and never accept a share key.
+	CreateArtifactShare(ctx context.Context, share *domain.ArtifactShare, maxCount int, maxBytes int64) error
+	ClaimArtifactShareUpload(ctx context.Context, id, userID, claimID string, at, leaseExpiresAt time.Time) (*domain.ArtifactShare, error)
+	MarkArtifactShareUploaded(ctx context.Context, id, userID, claimID string, generation int, digest string, at time.Time) error
+	ReleaseArtifactShareUpload(ctx context.Context, id, userID, claimID string, generation int) bool
+	CompleteArtifactShare(ctx context.Context, id, userID, digest string, metadata domain.EncryptedArtifactMetadata, at time.Time) (*domain.ArtifactShare, error)
+	ListArtifactSharesForUser(ctx context.Context, userID, artifactID string) ([]domain.ArtifactShare, error)
+	GetPublicArtifactShare(ctx context.Context, id string, at time.Time) (*domain.ArtifactShare, error)
+	RevokeArtifactShare(ctx context.Context, id, userID string, at time.Time) (*domain.ArtifactShare, error)
+	ListArtifactSharesForGC(ctx context.Context, before time.Time, limit int) ([]domain.ArtifactShare, error)
+	MarkArtifactShareObjectsDeleted(ctx context.Context, id string, at time.Time) error
+
 	// --- Device relay (docs/17 §4 — P2) ---------------------------------------
 	// Sessions/events/commands are the relay's data plane. Meta/envelope blobs
 	// are OPAQUE to the store (plaintext JSON in M3, E2EE ciphertext from M5):
diff --git a/shared/artifact-share-v1.json b/shared/artifact-share-v1.json
new file mode 100644
index 00000000..69f6ec69
--- /dev/null
+++ b/shared/artifact-share-v1.json
@@ -0,0 +1,14 @@
+{
+  "protocol": "jcode-artifact-share-v1",
+  "share_id": "share-vector-1",
+  "artifact_id": "artifact_vector_1",
+  "revision": 3,
+  "key_b64url": "AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA",
+  "metadata_plaintext": "{\"title\":\"Cross-runtime report\",\"relative_path\":\"reports/vector.md\",\"media_type\":\"text/markdown\",\"kind\":\"markdown\",\"size\":31}",
+  "metadata_nonce_b64url": "CwwNDg8QERITFBUW",
+  "metadata_ciphertext_b64url": "PCNe9QCm_5U0umhdsLdK7TtyBbN8pu-t4smkfT-2XYcq-2JUyD4cIfOBeanG3zDPLlJTLXRXxL4xvrVoPMmMP5kigmXs6mD-kCQbczKrspa8SYhQK0tMMsLOB-x2hWfH4L5eEJlJHlhedcjHs9pOk-lkjP1GTZLZ1E9ej7Dih0FHU-TF9xJKTEPWFton",
+  "content_plaintext_b64url": "IyBJbnRlcm9wCgpFbmNyeXB0ZWQgaW4gSkNvZGUuCg",
+  "content_nonce_b64url": "HyAhIiMkJSYnKCkq",
+  "content_wire_b64url": "HyAhIiMkJSYnKCkq2xKsh6NOnLDnqssEWDOZS1uvsdcYXDckbV5MZhzAafl-e395eaPl28tng3dC8bo",
+  "content_wire_sha256": "1f71a86a9d4dc5a71fc0f8a3063ec97688c941394e76a9f7a743a519a26ea053"
+}