diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 42cb2ec..6e6ed27 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -57,6 +57,78 @@ jobs:
       - name: Check packaging contract
         run: pnpm test:packaging
 
+  legacy-bridge-continuity:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
+    steps:
+      - name: Check out exact T4 source
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+        with:
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@b906affcce14559ad1aafd4ab0e942779e9f58b1 # v4
+        with:
+          version: 11.10.0
+
+      - name: Install Node.js
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        with:
+          node-version: 24.13.1
+          cache: pnpm
+
+      - name: Install Bun
+        uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
+        with:
+          bun-version: 1.3.14
+
+      - name: Install continuity prerequisites
+        run: sudo apt-get update && sudo apt-get install --yes expect
+
+      - name: Install T4 dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Resolve pinned OMP authority source
+        id: authority
+        shell: bash
+        run: |
+          set -euo pipefail
+          source_repository="$(jq -er '.sourceRepository' provenance/omp-host-migration.json)"
+          test "$source_repository" = "https://github.com/lyc-aon/oh-my-pi"
+          sha="$(jq -er '.inputs.operationsContinuity' provenance/omp-host-migration.json)"
+          [[ "$sha" =~ ^[0-9a-f]{40}$ ]]
+          echo "repository=lyc-aon/oh-my-pi" >> "$GITHUB_OUTPUT"
+          echo "sha=$sha" >> "$GITHUB_OUTPUT"
+
+      - name: Check out pinned OMP authority source
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+        with:
+          repository: ${{ steps.authority.outputs.repository }}
+          ref: ${{ steps.authority.outputs.sha }}
+          path: .continuity/omp
+
+      - name: Install OMP authority dependencies
+        working-directory: .continuity/omp
+        run: bun install --frozen-lockfile
+
+      - name: Build OMP native addon
+        working-directory: .continuity/omp
+        run: bun run build:native
+
+      - name: Run legacy bridge continuity gate
+        env:
+          T4_OMP_SOURCE_DIR: ${{ github.workspace }}/.continuity/omp
+        run: pnpm test:legacy-bridge-continuity
+
+      - name: Upload continuity evidence
+        if: ${{ always() }}
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        with:
+          name: legacy-bridge-continuity-${{ github.run_id }}
+          path: artifacts/legacy-bridge-continuity/
+          if-no-files-found: error
+          retention-days: 14
+
   tooling:
     runs-on: ubuntu-24.04
     timeout-minutes: 25
@@ -124,7 +196,7 @@ jobs:
   verify:
     name: verify
     if: ${{ always() }}
-    needs: [core, tooling, android-debug]
+    needs: [core, legacy-bridge-continuity, tooling, android-debug]
     runs-on: ubuntu-24.04
     timeout-minutes: 5
     steps:
@@ -132,10 +204,12 @@ jobs:
         shell: bash
         env:
           CORE_RESULT: ${{ needs.core.result }}
+          CONTINUITY_RESULT: ${{ needs.legacy-bridge-continuity.result }}
           TOOLING_RESULT: ${{ needs.tooling.result }}
           ANDROID_RESULT: ${{ needs.android-debug.result }}
         run: |
           set -euo pipefail
           test "$CORE_RESULT" = success
+          test "$CONTINUITY_RESULT" = success
           test "$TOOLING_RESULT" = success
           test "$ANDROID_RESULT" = success
diff --git a/.gitignore b/.gitignore
index ad5f758..e2d729c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,7 +18,8 @@ dist-electron/
 !.env.example
 
 # Test and runtime output
-/artifacts/operations-continuity/
+/artifacts/legacy-bridge-continuity/
+/.continuity/
 /evidence/wire/
 coverage/
 playwright-report/
diff --git a/apps/web/src/features/session-runtime/live-runtime.ts b/apps/web/src/features/session-runtime/live-runtime.ts
index 898f29d..0b6a9f5 100644
--- a/apps/web/src/features/session-runtime/live-runtime.ts
+++ b/apps/web/src/features/session-runtime/live-runtime.ts
@@ -50,6 +50,7 @@ import { pendingPromptsFromRef } from "./pending-prompts.ts";
 import {
   createTranscriptArtifactSource,
   type TranscriptImageAvailability,
+  type TranscriptMediaReference,
 } from "./transcript-images.ts";
 import {
   commandSupport,
@@ -300,24 +301,30 @@ export function createLiveSessionRuntime(options: LiveRuntimeOptions): SessionRu
 
   const transcriptImageAvailability = (
     runtime: DesktopRuntimeSnapshot,
+    reference: TranscriptMediaReference,
   ): TranscriptImageAvailability => {
     if (runtime.connections.get(targetId) !== "connected") {
-      return { available: false, reason: "Reconnect to this host to load transcript images." };
+      return { available: false, reason: "Reconnect to this host to load transcript media." };
     }
     const host = runtime.hosts.get(options.hostId);
+    const noun = "source" in reference ? "artifact" : "transcript image";
     if (host === undefined || !host.grantedCapabilities.includes("sessions.read")) {
       return {
         available: false,
-        reason: "This target does not grant transcript image access.",
+        reason: `This target does not grant ${noun} access.`,
       };
     }
     if (
-      !host.grantedFeatures.includes("transcript.images") &&
-      !host.grantedFeatures.includes("artifacts.read")
+      "source" in reference
+        ? !host.grantedFeatures.includes("artifacts.read")
+        : !host.grantedFeatures.includes("transcript.images")
     ) {
       return {
         available: false,
-        reason: "This OMP host does not offer transcript image reads.",
+        reason:
+          "source" in reference
+            ? "This host does not offer artifact reads."
+            : "This OMP host does not offer transcript image reads.",
       };
     }
     if (!transcriptImagesAttached) {
@@ -327,9 +334,10 @@ export function createLiveSessionRuntime(options: LiveRuntimeOptions): SessionRu
   };
 
   const syncTranscriptImageAvailability = (runtime: DesktopRuntimeSnapshot) => {
-    transcriptImages.setAvailability(transcriptImageAvailability(runtime));
+    transcriptImages.setAvailability((reference) => transcriptImageAvailability(runtime, reference));
   };
 
+
   const warmSession = (runtime: DesktopRuntimeSnapshot): SessionProjection | undefined =>
     runtime.projection.sessions.get(projectionKey);
 
diff --git a/apps/web/src/features/session-runtime/transcript-images.ts b/apps/web/src/features/session-runtime/transcript-images.ts
index 02013f4..51bfb40 100644
--- a/apps/web/src/features/session-runtime/transcript-images.ts
+++ b/apps/web/src/features/session-runtime/transcript-images.ts
@@ -34,6 +34,10 @@ export type TranscriptImageAvailability =
   | { readonly available: true }
   | { readonly available: false; readonly reason: string };
 
+export type TranscriptMediaAvailability =
+  | TranscriptImageAvailability
+  | ((reference: TranscriptMediaReference) => TranscriptImageAvailability);
+
 export type TranscriptImageSnapshot =
   | { readonly status: "loading" }
   | {
@@ -74,7 +78,7 @@ interface TranscriptMediaSourceOptions<TReference extends TranscriptMediaReferen
     offset: number,
     signal: TranscriptImageReadSignal,
   ) => Promise<TranscriptImageCommandResult>;
-  readonly availability?: TranscriptImageAvailability;
+  readonly availability?: TranscriptMediaAvailability;
   readonly hostId?: string;
   readonly sessionId?: string;
   readonly maxCacheBytes?: number;
@@ -622,9 +626,9 @@ export class ManagedTranscriptImageSource implements TranscriptImageSource {
   private readonly sessionId: string | undefined;
   private readonly entries = new Map<string, CacheEntry>();
   private readonly pendingLoads: CacheEntry[] = [];
-  private availability: TranscriptImageAvailability;
-  private unavailable: TranscriptImageSnapshot | null;
+  private availability: TranscriptMediaAvailability;
   private readonly pausedSnapshot = unavailableSnapshot(TRANSCRIPT_IMAGE_PAUSED_REASON);
+  private readonly unavailableSnapshots = new Map<string, TranscriptImageSnapshot>();
   private paused = false;
   private disposedReason: string | null = null;
   private disposedSnapshot: TranscriptImageSnapshot | null = null;
@@ -660,9 +664,6 @@ export class ManagedTranscriptImageSource implements TranscriptImageSource {
       available: false,
       reason: TRANSCRIPT_IMAGE_FIXTURE_REASON,
     };
-    this.unavailable = this.availability.available
-      ? null
-      : unavailableSnapshot(this.availability.reason);
     this.hostId = options.hostId;
     this.sessionId = options.sessionId;
     if (this.hostId !== undefined && this.sessionId !== undefined) {
@@ -670,18 +671,14 @@ export class ManagedTranscriptImageSource implements TranscriptImageSource {
     }
   }
 
-  setAvailability(availability: TranscriptImageAvailability): void {
+  setAvailability(availability: TranscriptMediaAvailability): void {
     if (this.disposedReason !== null) return;
-    const unchanged =
-      this.availability.available === availability.available &&
-      (this.availability.available ||
-        (!availability.available && this.availability.reason === availability.reason));
-    if (unchanged) return;
-    const becameAvailable = !this.availability.available && availability.available;
+    const previous = this.availability;
     this.availability = availability;
-    this.unavailable = availability.available ? null : unavailableSnapshot(availability.reason);
     for (const entry of this.entries.values()) {
-      if (!availability.available) {
+      const before = this.availabilityFor(entry.reference, previous);
+      const after = this.availabilityFor(entry.reference);
+      if (!after.available) {
         if (entry.state === "queued") this.cancelQueued(entry);
         if (entry.state === "waiting") {
           entry.state = "idle";
@@ -689,28 +686,37 @@ export class ManagedTranscriptImageSource implements TranscriptImageSource {
         }
         if (entry.state === "loading") this.cancelActive(entry);
       }
-      if (becameAvailable && entry.state === "error" && entry.retryable) {
+      if (!before.available && after.available && entry.state === "error" && entry.retryable) {
         entry.state = "idle";
         entry.snapshot = null;
       }
       this.notify(entry);
-      if (!this.paused && availability.available && entry.refCount > 0 && entry.state === "idle") {
+      if (!this.paused && after.available && entry.refCount > 0 && entry.state === "idle") {
         this.start(entry);
       }
     }
-    if (!this.paused && availability.available) this.drainQueue();
+    if (!this.paused) this.drainQueue();
   }
 
   getSnapshot(reference: TranscriptMediaReference): TranscriptImageSnapshot {
     if (this.disposedSnapshot !== null) return this.disposedSnapshot;
     if (this.paused) return this.pausedSnapshot;
     const entry = this.entries.get(mediaKey(reference));
+    const availability = this.availabilityFor(reference);
+    if (!availability.available) return this.unavailableSnapshot(availability.reason);
     if (entry?.state === "ready" && entry.snapshot !== null) return entry.snapshot;
-    if (this.unavailable !== null) return this.unavailable;
     if (entry?.state === "error" && entry.snapshot !== null) return entry.snapshot;
     return LOADING_SNAPSHOT;
   }
 
+  private unavailableSnapshot(reason: string): TranscriptImageSnapshot {
+    const existing = this.unavailableSnapshots.get(reason);
+    if (existing !== undefined) return existing;
+    const snapshot = unavailableSnapshot(reason);
+    this.unavailableSnapshots.set(reason, snapshot);
+    return snapshot;
+  }
+
   subscribe(reference: TranscriptMediaReference, listener: () => void): () => void {
     if (this.disposedReason !== null) return () => undefined;
     const entry = this.ensureEntry(reference);
@@ -732,7 +738,7 @@ export class ManagedTranscriptImageSource implements TranscriptImageSource {
       entry.snapshot = null;
       this.notify(entry);
     }
-    if (this.availability.available && entry.state === "idle") this.start(entry);
+    if (this.availabilityFor(entry.reference).available && entry.state === "idle") this.start(entry);
     let retained = true;
     return () => {
       if (!retained) return;
@@ -810,11 +816,15 @@ export class ManagedTranscriptImageSource implements TranscriptImageSource {
     this.paused = false;
     for (const entry of this.entries.values()) {
       this.notify(entry);
-      if (this.availability.available && entry.refCount > 0 && entry.state === "idle") {
+      if (
+        this.availabilityFor(entry.reference).available &&
+        entry.refCount > 0 &&
+        entry.state === "idle"
+      ) {
         this.start(entry);
       }
     }
-    if (this.availability.available) this.drainQueue();
+    this.drainQueue();
   }
 
   dispose(reason = "Transcript image cache was closed."): void {
@@ -870,6 +880,12 @@ export class ManagedTranscriptImageSource implements TranscriptImageSource {
     this.entries.set(key, entry);
     return entry;
   }
+  private availabilityFor(
+    reference: TranscriptMediaReference,
+    availability = this.availability,
+  ): TranscriptImageAvailability {
+    return typeof availability === "function" ? availability(reference) : availability;
+  }
 
   private touch(entry: CacheEntry): void {
     this.clock += 1;
@@ -881,9 +897,13 @@ export class ManagedTranscriptImageSource implements TranscriptImageSource {
   }
 
   private retryCapacityWaiters(): void {
-    if (this.disposedReason !== null || this.paused || !this.availability.available) return;
+    if (this.disposedReason !== null || this.paused) return;
     for (const entry of this.entries.values()) {
-      if (entry.refCount > 0 && entry.state === "waiting") {
+      if (
+        this.availabilityFor(entry.reference).available &&
+        entry.refCount > 0 &&
+        entry.state === "waiting"
+      ) {
         entry.state = "idle";
         entry.snapshot = null;
         this.notify(entry);
@@ -896,7 +916,7 @@ export class ManagedTranscriptImageSource implements TranscriptImageSource {
     if (
       this.disposedReason !== null ||
       this.paused ||
-      !this.availability.available ||
+      !this.availabilityFor(entry.reference).available ||
       entry.refCount <= 0 ||
       entry.state !== "idle" ||
       entry.promise !== null ||
@@ -914,12 +934,13 @@ export class ManagedTranscriptImageSource implements TranscriptImageSource {
   }
 
   private drainQueue(): void {
-    if (this.disposedReason !== null || this.paused || !this.availability.available) return;
+    if (this.disposedReason !== null || this.paused) return;
     while (this.activeLoads < this.maxConcurrentLoads && this.pendingLoads.length > 0) {
       const entry = this.pendingLoads.shift();
       if (
         entry === undefined ||
         this.entries.get(entry.key) !== entry ||
+        !this.availabilityFor(entry.reference).available ||
         entry.refCount <= 0 ||
         entry.state !== "queued" ||
         !entry.queued
@@ -941,7 +962,7 @@ export class ManagedTranscriptImageSource implements TranscriptImageSource {
         if (
           this.disposedReason === null &&
           !this.paused &&
-          this.availability.available &&
+          this.availabilityFor(entry.reference).available &&
           this.entries.get(entry.key) === entry &&
           entry.refCount > 0 &&
           entry.state === "idle"
@@ -1096,8 +1117,7 @@ export class ManagedTranscriptImageSource implements TranscriptImageSource {
       if (chunks > TRANSCRIPT_IMAGE_MAX_CHUNKS) {
         throw new TranscriptImageFailure(TRANSCRIPT_IMAGE_PROTOCOL_ERROR, false);
       }
-      this.assertCurrent(entry, signal);
-      if (!this.availability.available) {
+      if (!this.availabilityFor(entry.reference).available) {
         throw new TranscriptImageFailure(TRANSCRIPT_IMAGE_LOAD_ERROR, true);
       }
       let response: TranscriptImageCommandResult;
diff --git a/apps/web/src/features/transcript/TranscriptArtifacts.tsx b/apps/web/src/features/transcript/TranscriptArtifacts.tsx
index e2ece74..645d0a1 100644
--- a/apps/web/src/features/transcript/TranscriptArtifacts.tsx
+++ b/apps/web/src/features/transcript/TranscriptArtifacts.tsx
@@ -17,6 +17,14 @@ function labelFor(artifact: TranscriptArtifactReference): string {
   return artifact.name ?? `${artifact.kind} artifact`;
 }
 
+export function artifactOpensInline(artifact: TranscriptArtifactReference): boolean {
+  return artifact.kind === "image" && artifact.disposition === "inline";
+}
+
+export function artifactDownloadLabel(artifact: TranscriptArtifactReference): string {
+  return artifact.sha256 === undefined ? "Download artifact" : "Download verified artifact";
+}
+
 function ArtifactCard({
   artifact,
   source,
@@ -24,7 +32,7 @@ function ArtifactCard({
   readonly artifact: TranscriptArtifactReference;
   readonly source: TranscriptImageSource;
 }) {
-  const [open, setOpen] = useState(artifact.kind === "image");
+  const [open, setOpen] = useState(() => artifactOpensInline(artifact));
   const [text, setText] = useState<string | null>(null);
   const snapshot = useSyncExternalStore(
     (listener) => source.subscribe(artifact, listener),
@@ -78,7 +86,7 @@ function ArtifactCard({
         <span className="min-w-0 flex-1 truncate text-xs font-medium">{labelFor(artifact)}</span>
         <span className="shrink-0 text-muted-foreground text-xs">{artifact.kind}</span>
       </div>
-      {artifact.kind === "image" && snapshot.status === "ready" && (
+      {artifact.kind === "image" && open && snapshot.status === "ready" && (
         <img
           className="mt-2 max-h-52 max-w-full rounded object-contain"
           src={snapshot.url}
@@ -86,6 +94,17 @@ function ArtifactCard({
           onError={() => source.reportDecodeFailure(artifact)}
         />
       )}
+      {artifact.kind === "image" && artifact.disposition === "attachment" && (
+        <Button
+          className="mt-2 min-h-8"
+          size="sm"
+          variant="outline"
+          onClick={() => setOpen((value) => !value)}
+          aria-expanded={open}
+        >
+          {open ? "Close image" : "Open image"}
+        </Button>
+      )}
       {snapshot.status === "loading" && open && (
         <p className="mt-2 flex items-center gap-1 text-muted-foreground text-xs" role="status">
           <LoaderCircle aria-hidden="true" className="size-3 animate-spin" />
@@ -133,7 +152,7 @@ function ArtifactCard({
           href={snapshot.url}
           download={artifact.name ?? "artifact"}
         >
-          Download verified artifact
+          {artifactDownloadLabel(artifact)}
         </a>
       )}
     </article>
diff --git a/apps/web/src/features/transcript/export.test.ts b/apps/web/src/features/transcript/export.test.ts
index 4c8f98a..9d6c5dc 100644
--- a/apps/web/src/features/transcript/export.test.ts
+++ b/apps/web/src/features/transcript/export.test.ts
@@ -2,7 +2,7 @@
 // view was; every row kind serializes; unknown entries are preserved, never
 // dropped; the transient working row is omitted; Markdown caps long tool
 // output while JSON preserves durable rows; filenames are filesystem-safe.
-import { describe, expect, it } from "vite-plus/test";
+import { describe, expect, it, vi } from "vite-plus/test";
 
 import {
   EXPORT_TOOL_OUTPUT_MAX_CHARS,
@@ -116,6 +116,80 @@ describe("transcriptRowsToMarkdown", () => {
     expect(out).toContain('"exitCode": 0');
   });
 
+  it("preserves artifact metadata and issues without fetching message or tool bytes", () => {
+    const fetch = vi.spyOn(globalThis, "fetch");
+    const messageArtifact = {
+      artifactId: "message-artifact",
+      kind: "image" as const,
+      mediaType: "image/png",
+      disposition: "attachment" as const,
+      retention: "session" as const,
+      sha256: "a".repeat(64),
+      source: "artifact" as const,
+    };
+    const toolArtifact = {
+      artifactId: "tool-artifact",
+      kind: "patch" as const,
+      mediaType: "text/x-diff",
+      disposition: "inline" as const,
+      retention: "session" as const,
+      name: "fix.patch",
+      source: "artifact" as const,
+    };
+
+    try {
+      const out = transcriptRowsToMarkdown(
+        [
+          messageRow({
+            artifacts: [messageArtifact],
+            artifactIssue: "Message artifact metadata was incomplete.",
+          }),
+          {
+            id: "g1",
+            kind: "tool-group",
+            calls: [
+              toolCall({
+                artifacts: [toolArtifact],
+                artifactIssue: "Tool artifact metadata was incomplete.",
+              }),
+            ],
+            running: false,
+          },
+        ],
+        meta(),
+      );
+
+      expect(out).toContain('"artifactId": "message-artifact"');
+      expect(out).toContain('"artifactId": "tool-artifact"');
+      expect(out).toContain('"sha256": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"');
+      expect(out).toContain('"name": "fix.patch"');
+      expect(out).toContain("> Artifact issue: Message artifact metadata was incomplete.");
+      expect(out).toContain("> Artifact issue: Tool artifact metadata was incomplete.");
+      expect(fetch).not.toHaveBeenCalled();
+    } finally {
+      fetch.mockRestore();
+    }
+  });
+
+  it("preserves artifact metadata beyond the tool-output readability cap", () => {
+    const artifacts = Array.from({ length: 64 }, (_, index) => ({
+      artifactId: `artifact-${index}`,
+      kind: "text" as const,
+      mediaType: "text/plain",
+      disposition: "attachment" as const,
+      retention: "session" as const,
+      name: `${index}-${"x".repeat(256)}.txt`,
+      source: "artifact" as const,
+    }));
+    const out = transcriptRowsToMarkdown(
+      [messageRow({ artifacts, artifactIssue: null })],
+      meta(),
+    );
+
+    expect(out).toContain('"artifactId": "artifact-63"');
+    expect(out).not.toContain("truncated for export");
+  });
+
   it("marks running and errored calls", () => {
     const out = transcriptRowsToMarkdown(
       [
diff --git a/apps/web/src/features/transcript/export.ts b/apps/web/src/features/transcript/export.ts
index 4a710b2..9f39ba0 100644
--- a/apps/web/src/features/transcript/export.ts
+++ b/apps/web/src/features/transcript/export.ts
@@ -45,8 +45,8 @@ function boundedBlock(value: unknown): string {
   return `${text.slice(0, EXPORT_TOOL_OUTPUT_MAX_CHARS)}\n… truncated for export`;
 }
 
-function fencedJson(value: unknown): string {
-  const content = boundedBlock(value);
+function fencedJson(value: unknown, bounded = true): string {
+  const content = bounded ? boundedBlock(value) : (JSON.stringify(value, null, 2) ?? "null");
   let longestBacktickRun = 0;
   for (const match of content.matchAll(/`+/g)) {
     longestBacktickRun = Math.max(longestBacktickRun, match[0].length);
@@ -61,6 +61,18 @@ function toolCallStatus(call: TranscriptToolCall): string {
   return "running";
 }
 
+function artifactMetadataToMarkdown(
+  artifacts: TranscriptToolCall["artifacts"] | undefined,
+  issue: string | null | undefined,
+): string[] {
+  const parts: string[] = [];
+  if (artifacts !== undefined && artifacts.length > 0) {
+    parts.push(`Artifacts:\n\n${fencedJson(artifacts, false)}`);
+  }
+  if (issue !== null && issue !== undefined) parts.push(`> Artifact issue: ${issue}`);
+  return parts;
+}
+
 function toolCallToMarkdown(call: TranscriptToolCall): string {
   const parts = [`### ${call.title} (\`${call.tool}\`) — ${toolCallStatus(call)}`];
   if (Object.keys(call.args).length > 0) {
@@ -75,6 +87,7 @@ function toolCallToMarkdown(call: TranscriptToolCall): string {
   if (call.images.length > 0) {
     parts.push(`_${call.images.length} image(s) attached_`);
   }
+  parts.push(...artifactMetadataToMarkdown(call.artifacts, call.artifactIssue));
   return parts.join("\n\n");
 }
 
@@ -125,6 +138,7 @@ function rowToMarkdown(row: TranscriptRow): string | null {
       if (row.text !== "") parts.push(row.text);
       if (row.images.length > 0) parts.push(`_${row.images.length} image(s) attached_`);
       if (row.imageIssue !== null) parts.push(`> Image issue: ${row.imageIssue}`);
+      parts.push(...artifactMetadataToMarkdown(row.artifacts, row.artifactIssue));
       return parts.join("\n\n");
     }
     case "tool-group":
diff --git a/apps/web/test/transcript-artifact-components.test.tsx b/apps/web/test/transcript-artifact-components.test.tsx
new file mode 100644
index 0000000..6b11809
--- /dev/null
+++ b/apps/web/test/transcript-artifact-components.test.tsx
@@ -0,0 +1,81 @@
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, it } from "vite-plus/test";
+
+import type {
+  TranscriptImageSnapshot,
+  TranscriptImageSource,
+} from "../src/features/session-runtime/transcript-images.ts";
+import {
+  artifactDownloadLabel,
+  artifactOpensInline,
+  TranscriptArtifacts,
+} from "../src/features/transcript/TranscriptArtifacts.tsx";
+import type { TranscriptArtifactReference } from "../src/features/transcript/artifact-metadata.ts";
+
+function artifact(
+  overrides: Partial<TranscriptArtifactReference> = {},
+): TranscriptArtifactReference {
+  return {
+    artifactId: "artifact-1",
+    kind: "image",
+    mediaType: "image/png",
+    disposition: "inline",
+    retention: "session",
+    source: "artifact",
+    ...overrides,
+  };
+}
+
+function source(snapshot: TranscriptImageSnapshot): TranscriptImageSource {
+  return {
+    getSnapshot: () => snapshot,
+    subscribe: () => () => undefined,
+    retain: () => () => undefined,
+    reportDecodeFailure: () => undefined,
+    dispose: () => undefined,
+  };
+}
+
+describe("transcript artifact presentation", () => {
+  it("opens only inline image artifacts automatically", () => {
+    const inline = artifact();
+    const attachment = artifact({ artifactId: "attachment-1", disposition: "attachment" });
+
+    expect(artifactOpensInline(inline)).toBe(true);
+    expect(artifactOpensInline(attachment)).toBe(false);
+
+    const markup = renderToStaticMarkup(
+      <TranscriptArtifacts
+        artifacts={[attachment]}
+        issue={null}
+        label="Response"
+        source={source({
+          status: "ready",
+          url: "blob:attachment",
+          mimeType: "image/png",
+          size: 42,
+          animated: false,
+        })}
+      />,
+    );
+
+    expect(markup).toContain("Open image");
+    expect(markup).not.toContain('src="blob:attachment"');
+  });
+
+  it("labels binary downloads as verified only when the descriptor has a digest", () => {
+    expect(
+      artifactDownloadLabel(artifact({ artifactId: "plain", kind: "binary", disposition: "attachment" })),
+    ).toBe("Download artifact");
+    expect(
+      artifactDownloadLabel(
+        artifact({
+          artifactId: "verified",
+          kind: "binary",
+          disposition: "attachment",
+          sha256: "a".repeat(64),
+        }),
+      ),
+    ).toBe("Download verified artifact");
+  });
+});
diff --git a/apps/web/test/transcript-images.test.ts b/apps/web/test/transcript-images.test.ts
index 5fa4919..48973f2 100644
--- a/apps/web/test/transcript-images.test.ts
+++ b/apps/web/test/transcript-images.test.ts
@@ -27,6 +27,7 @@ import {
   type TranscriptImageCommandResult,
   type TranscriptImageSnapshot,
   type TranscriptImageSource,
+  type TranscriptMediaReference,
 } from "../src/features/session-runtime/transcript-images.ts";
 import {
   INVALID_TRANSCRIPT_IMAGE_METADATA,
@@ -34,6 +35,7 @@ import {
   type TranscriptImageMimeType,
   type TranscriptImageReference,
 } from "../src/features/transcript/image-metadata.ts";
+import type { TranscriptArtifactReference } from "../src/features/transcript/artifact-metadata.ts";
 import { initialProjection, reduceTranscript } from "../src/features/transcript/projection.ts";
 import { deriveTranscriptRows } from "../src/features/transcript/rows.ts";
 import { deferred, FakeShell, makeWelcome } from "./fake-shell.ts";
@@ -117,9 +119,30 @@ function responseFor(
   };
 }
 
+function artifactResponseFor(
+  bytes: Uint8Array,
+  artifact: TranscriptArtifactReference,
+  offset: number,
+): TranscriptImageCommandResult {
+  const nextOffset = Math.min(offset + TRANSCRIPT_IMAGE_CHUNK_BYTES, bytes.byteLength);
+  return {
+    accepted: true,
+    result: {
+      artifactId: artifact.artifactId,
+      kind: artifact.kind,
+      mediaType: artifact.mediaType,
+      size: bytes.byteLength,
+      offset,
+      nextOffset,
+      complete: nextOffset === bytes.byteLength,
+      content: base64(bytes.subarray(offset, nextOffset)),
+    },
+  };
+}
+
 async function waitForStatus(
   source: TranscriptImageSource,
-  image: TranscriptImageReference,
+  image: TranscriptMediaReference,
   status: TranscriptImageSnapshot["status"],
 ): Promise<TranscriptImageSnapshot> {
   const initial = source.getSnapshot(image);
@@ -847,6 +870,7 @@ describe("bounded transcript image source", () => {
       status: "unavailable",
       reason: "Waiting for the host.",
     });
+    expect(source.getSnapshot(image)).toBe(source.getSnapshot(image));
     expect(reads).toBe(0);
 
     source.setAvailability({ available: true });
@@ -856,6 +880,47 @@ describe("bounded transcript image source", () => {
     source.dispose();
   });
 
+  it("hides cached legacy images and artifacts when their capability is revoked", async () => {
+    const bytes = pngBytes();
+    const image = await reference(bytes, { entryId: "revoked-image" });
+    const artifact: TranscriptArtifactReference = {
+      artifactId: "revoked-artifact",
+      kind: "image",
+      mediaType: "image/png",
+      disposition: "inline",
+      retention: "session",
+      source: "artifact",
+    };
+    const source = createTranscriptImageSource({
+      availability: { available: true },
+      readChunk: async (nextReference, offset) =>
+        "artifactId" in nextReference
+          ? artifactResponseFor(bytes, artifact, offset)
+          : responseFor(bytes, image, offset),
+      createObjectUrl: (blob) => `blob:revoked-${blob.size}`,
+    });
+    const releaseImage = source.retain(image);
+    const releaseArtifact = source.retain(artifact);
+    expect((await waitForStatus(source, image, "ready")).status).toBe("ready");
+    expect((await waitForStatus(source, artifact, "ready")).status).toBe("ready");
+
+    source.setAvailability((nextReference) => ({
+      available: false,
+      reason: "artifactId" in nextReference ? "Artifact access revoked." : "Image access revoked.",
+    }));
+    expect(source.getSnapshot(image)).toEqual({
+      status: "unavailable",
+      reason: "Image access revoked.",
+    });
+    expect(source.getSnapshot(artifact)).toEqual({
+      status: "unavailable",
+      reason: "Artifact access revoked.",
+    });
+    releaseArtifact();
+    releaseImage();
+    source.dispose();
+  });
+
   it("clears transient failure state so a later retain can retry cleanly", async () => {
     const bytes = pngBytes();
     const image = await reference(bytes);
@@ -1100,12 +1165,94 @@ describe("runtime capability gating", () => {
     await controller.stop();
   });
 
+  it("gates mixed legacy images and generic artifacts by their own feature", async () => {
+    const bytes = pngBytes();
+    const image = await reference(bytes, { entryId: "legacy-image" });
+    const artifact: TranscriptArtifactReference = {
+      artifactId: "generic-image",
+      kind: "image",
+      mediaType: "image/png",
+      disposition: "inline",
+      retention: "session",
+      source: "artifact",
+    };
+
+    const run = async (
+      features: readonly string[],
+      available: TranscriptMediaReference,
+      unavailable: TranscriptMediaReference,
+      expectedCommand: "session.image.read" | "artifact.read",
+    ) => {
+      const shell = new FakeShell();
+      shell.command = async (request: CommandRequest): Promise<CommandResult> => {
+        shell.commands.push(request);
+        const result =
+          request.intent.command === "session.image.read"
+            ? responseFor(bytes, image, Number(request.intent.args?.offset)).result
+            : request.intent.command === "artifact.read"
+              ? artifactResponseFor(bytes, artifact, Number(request.intent.args?.offset)).result
+              : { accepted: true };
+        return {
+          targetId: request.targetId,
+          requestId: `mixed-media-${shell.commands.length}`,
+          commandId: `mixed-media-command-${shell.commands.length}`,
+          accepted: true,
+          result,
+        };
+      };
+      const controller = createDesktopRuntimeController({ shell });
+      await controller.start();
+      try {
+        shell.emitFrame({ targetId: "local", frame: makeWelcome(HOST, ["sessions.read"], features) });
+        shell.emitFrame({ targetId: "local", frame: snapshot() });
+        const runtime = createLiveSessionRuntime({
+          controller,
+          targetId: "local",
+          hostId: HOST,
+          sessionId: SESSION,
+        });
+        try {
+          const releaseAvailable = runtime.transcriptImages.retain(available);
+          const releaseUnavailable = runtime.transcriptImages.retain(unavailable);
+          try {
+            expect(await waitForStatus(runtime.transcriptImages, available, "ready")).toMatchObject({
+              status: "ready",
+            });
+            await vi.waitFor(() =>
+              expect(runtime.transcriptImages.getSnapshot(unavailable)).toMatchObject({
+                status: "unavailable",
+              }),
+            );
+            expect(
+              shell.commands
+                .map((request) => request.intent.command)
+                .filter(
+                  (command) => command === "session.image.read" || command === "artifact.read",
+                ),
+            ).toEqual([expectedCommand]);
+          } finally {
+            releaseUnavailable();
+            releaseAvailable();
+          }
+        } finally {
+          runtime.dispose();
+        }
+      } finally {
+        await controller.stop();
+      }
+    };
+
+    await run(["transcript.images"], image, artifact, "session.image.read");
+    await run(["artifacts.read"], artifact, image, "artifact.read");
+  });
+
   it("routes runtime pause and resume through reversible transcript-image eviction", async () => {
     const bytes = pngBytes(32, 43);
     const image = await reference(bytes, { entryId: "runtime-pause" });
     const shell = new FakeShell();
     shell.command = async (request: CommandRequest): Promise<CommandResult> => {
       shell.commands.push(request);
+
       const result =
         request.intent.command === "session.image.read"
           ? responseFor(bytes, image, Number(request.intent.args?.offset)).result
diff --git a/docs/RELEASE_GATE.md b/docs/RELEASE_GATE.md
index db43cd6..03ba438 100644
--- a/docs/RELEASE_GATE.md
+++ b/docs/RELEASE_GATE.md
@@ -22,17 +22,19 @@ Every release must pass the layers below. Destructive lifecycle checks use a dis
    - Use real CDP touch input at 320 pixels for model-list drag scrolling and selection. Check Send and session-management control reachability at 320, 360, and 390 pixels, including a short 390 x 500 viewport.
    - Open and close the session rail, create a session, reach the Send control, drag-scroll the model list, and select its last available model.
 
-## Operations continuity proof
+## Legacy bridge continuity proof
 
-Run the deterministic cross-runtime gate from the T4 repository root with Node 24.13.1 and a Lycaon OMP source worktree:
+Run the deterministic compatibility gate from the T4 repository root with Node 24.13.1 and the pinned Lycaon OMP source:
 
 ```sh
-T4_OMP_SOURCE_DIR=/path/to/lycaon-oh-my-pi pnpm test:operations:real
+T4_OMP_SOURCE_DIR=/path/to/lycaon-oh-my-pi pnpm test:legacy-bridge-continuity
 ```
 
-The gate creates two disposable OMP profiles, two project roots, 27 sessions, and a 10,000-entry transcript. It launches a real OMP TUI plus multiple production T4 clients, then verifies bounded transcript loading, live ownership refusal, concurrent profile isolation, reconnect after an in-flight transport loss, appserver restart recovery, transcript search/read-around, stale-revision rejection, and recovered control. The cleanup endpoint terminates test-owned RPC workers, removes only manifest-owned sessions, and must report zero indexed sessions, locks, workers, files, and errors. A second cleanup call proves idempotence.
+The gate intentionally launches the legacy OMP appserver from the pinned authority source, plus a real OMP TUI and multiple production T4 clients. It proves client compatibility across bounded transcript loading, live ownership refusal, concurrent profile isolation, reconnect after an in-flight transport loss, appserver restart recovery, transcript search/read-around, stale-revision rejection, recovered control, and cleanup. It does not claim that `@t4-code/host-service` is deployed; that requires the future thin OMP launcher and authority adapter.
 
-Each successful run writes machine-readable evidence under `artifacts/operations-continuity/<run>/`: `report.json`, sanitized `wire-events.ndjson`, `failure-matrix.json`, `cleanup-status.json`, and an executable `rollback.sh`. The report records both source commits, dirty-state fingerprints including untracked fixture files, bounded snapshot sizes, failure codes, delivered cursor integrity, profile overlap, restart persistence, search/context results, and cleanup state. These artifacts are local and ignored by Git.
+CI resolves the exact OMP authority commit from `provenance/omp-host-migration.json`, checks out the exact T4 pull-request head, runs this gate, and attaches the evidence directory to that commit's check run.
+
+Each successful run writes machine-readable evidence under `artifacts/legacy-bridge-continuity/<run>/`: `report.json`, sanitized `wire-events.ndjson`, `failure-matrix.json`, `cleanup-status.json`, and an executable `rollback.sh`. The report names the legacy host implementation, records both source commits and dirty-state fingerprints, and captures bounded snapshot sizes, failure codes, delivered cursor integrity, profile overlap, restart persistence, search/context results, and cleanup state. These artifacts are local and ignored by Git.
 
 For a manual failure investigation, rerun with `T4_KEEP_CONTINUITY_SANDBOX=1`. The failed run retains its disposable profile and writes `report.json` plus sanitized `wire-events.ndjson`; successful runs also include `rollback.sh`, which documents the authenticated cleanup request for an explicitly test-mode appserver. Never point the gate or rollback helper at a normal OMP profile.
 
diff --git a/docs/adr/013-t4-host-ownership.md b/docs/adr/013-t4-host-ownership.md
index c37b1fc..5c7a4bf 100644
--- a/docs/adr/013-t4-host-ownership.md
+++ b/docs/adr/013-t4-host-ownership.md
@@ -7,4 +7,5 @@
 - Runtime adapters: backend-neutral ACP adapters and Git workspace lifecycle belong to the T4 host. They report explicit availability and never silently fall back to another executable. An OMP adapter may offer the complete first-party experience while other adapters expose only the capabilities they can support honestly.
 - Transition: the verified OMP integration binary still embeds the legacy copy of the host while the thin bridge is prepared. T4 therefore continues to publish exact runtime provenance and does not claim that ordinary upstream OMP is compatible yet. The frozen `@oh-my-pi/app-wire` tarball remains as bridge evidence, not as T4's active protocol dependency. The compatibility projector can be removed only after OMP exposes an equally bounded public catalog and event bridge.
 - Fork reduction: the next OMP integration change should replace its generic appserver and app-wire implementation with the T4-owned packages, leaving a small launcher and OMP authority adapter. General OMP fixes should continue upstream as independent changes.
-- Verification: T4 runs the migrated wire and host suites, package-consumer checks, the real continuity gate, import-boundary checks, and release consistency checks. The compatibility matrix records the exact source inputs and the current deployment state.
+- Review and rollback boundaries: the package ownership import, runtime/workspace adapters, artifact and turn-review protocol, and Agent View UI remain separate commit and subsystem boundaries. A UI or protocol rollback does not require restoring OMP source ownership; a host deployment rollback continues to select the legacy embedded bridge until the thin launcher is ready.
+- Verification: T4 runs the migrated wire and host suites, package-consumer checks, import-boundary checks, and release consistency checks. A commit-bound legacy bridge continuity job checks the exact T4 head against the OMP authority commit recorded in provenance; it proves compatibility with the legacy OMP appserver, not deployment of the migrated host. The compatibility matrix records the exact source inputs and current deployment state.
diff --git a/package.json b/package.json
index 08e75d1..f39653d 100644
--- a/package.json
+++ b/package.json
@@ -36,7 +36,7 @@
     "test:e2e": "pnpm build:web && pnpm build:site && playwright test",
     "test:soak": "pnpm --filter @t4-code/client exec vp test run test/projection.test.ts -t \"retains a 10k snapshot\" && pnpm build:web && playwright test e2e/remote-app.spec.ts --grep \"@soak\"",
     "test:protocol": "vp run --filter @t4-code/protocol --filter @t4-code/fixture-server test",
-    "test:operations:real": "vp test run scripts/operations-continuity-real.test.ts --reporter=verbose",
+    "test:legacy-bridge-continuity": "vp test run scripts/legacy-bridge-continuity.test.ts --reporter=verbose",
     "perf:core": "vp test run scripts/perf/core.test.ts",
     "perf:ui": "pnpm build:web && node scripts/perf/ui.mjs",
     "perf:electron": "pnpm build:web && pnpm build:desktop && node scripts/perf/electron.mjs",
diff --git a/packages/host-service/src/artifact-reader.ts b/packages/host-service/src/artifact-reader.ts
index 6938325..101edc0 100644
--- a/packages/host-service/src/artifact-reader.ts
+++ b/packages/host-service/src/artifact-reader.ts
@@ -23,12 +23,20 @@ function sameFile(before: fs.Stats, after: fs.Stats): boolean {
 	);
 }
 
+const DIGEST_CACHE_LIMIT = 64;
+const DIGEST_READ_BYTES = 64 * 1024;
+
+function fileIdentity(info: fs.Stats): string {
+	return `${info.dev}:${info.ino}:${info.size}:${info.mtimeMs}:${info.ctimeMs}`;
+}
+
 function aborted(signal: AbortSignal | undefined): void {
 	if (signal?.aborted) throw new ArtifactReadError("connection_closed", "artifact read was cancelled");
 }
 
 /** Reads an already-authorized, session-local artifact in bounded chunks without exposing its path. */
 export class ArtifactReader {
+	readonly #verifiedDigests = new Map<string, undefined>();
 	async read(
 		root: string,
 		descriptor: ArtifactDescriptor,
@@ -86,18 +94,10 @@ export class ArtifactReader {
 				if (offset >= before.size)
 					throw new ArtifactReadError("artifact_invalid", "artifact offset exceeds its size");
 				const nextOffset = Math.min(offset + ARTIFACT_CHUNK_BYTES, before.size);
-				const data = Buffer.allocUnsafe(nextOffset - offset);
-				aborted(signal);
-				const { bytesRead } = await handle.read(data, 0, data.byteLength, offset);
-				const after = await handle.stat();
-				aborted(signal);
-				if (bytesRead !== data.byteLength || !sameFile(before, after))
-					throw new ArtifactReadError("artifact_invalid", "artifact changed while reading");
-				if (descriptor.sha256 !== undefined) {
-					const content = await fs.promises.readFile(path.join(canonicalRoot, fileName));
-					if (createHash("sha256").update(content).digest("hex") !== descriptor.sha256)
-						throw new ArtifactReadError("artifact_invalid", "artifact digest does not match its descriptor");
-				}
+				const data =
+					descriptor.sha256 === undefined
+						? await this.#readSlice(handle, before, offset, nextOffset, signal)
+						: await this.#readVerifiedSlice(handle, before, offset, nextOffset, descriptor.sha256, signal);
 				return {
 					artifactId: descriptor.artifactId,
 					kind: descriptor.kind,
@@ -119,4 +119,61 @@ export class ArtifactReader {
 			throw new ArtifactReadError("artifact_invalid", "artifact could not be read");
 		}
 	}
+	async #readSlice(
+		handle: fs.promises.FileHandle,
+		before: fs.Stats,
+		offset: number,
+		nextOffset: number,
+		signal: AbortSignal | undefined,
+	): Promise<Buffer> {
+		const data = Buffer.allocUnsafe(nextOffset - offset);
+		aborted(signal);
+		const { bytesRead } = await handle.read(data, 0, data.byteLength, offset);
+		const after = await handle.stat();
+		aborted(signal);
+		if (bytesRead !== data.byteLength || !sameFile(before, after))
+			throw new ArtifactReadError("artifact_invalid", "artifact changed while reading");
+		return data;
+	}
+
+	async #readVerifiedSlice(
+		handle: fs.promises.FileHandle,
+		before: fs.Stats,
+		offset: number,
+		nextOffset: number,
+		expectedDigest: string,
+		signal: AbortSignal | undefined,
+	): Promise<Buffer> {
+		const key = `${expectedDigest}:${fileIdentity(before)}`;
+		if (this.#verifiedDigests.has(key)) return this.#readSlice(handle, before, offset, nextOffset, signal);
+
+		const data = Buffer.allocUnsafe(nextOffset - offset);
+		const block = Buffer.allocUnsafe(Math.min(DIGEST_READ_BYTES, before.size));
+		const hash = createHash("sha256");
+		for (let position = 0; position < before.size; ) {
+			aborted(signal);
+			const length = Math.min(block.byteLength, before.size - position);
+			const { bytesRead } = await handle.read(block, 0, length, position);
+			if (bytesRead !== length) throw new ArtifactReadError("artifact_invalid", "artifact changed while reading");
+			hash.update(block.subarray(0, bytesRead));
+			const copyStart = Math.max(position, offset);
+			const copyEnd = Math.min(position + bytesRead, nextOffset);
+			if (copyStart < copyEnd)
+				block.copy(data, copyStart - offset, copyStart - position, copyEnd - position);
+			position += bytesRead;
+		}
+		const after = await handle.stat();
+		aborted(signal);
+		if (!sameFile(before, after)) throw new ArtifactReadError("artifact_invalid", "artifact changed while reading");
+		if (hash.digest("hex") !== expectedDigest)
+			throw new ArtifactReadError("artifact_invalid", "artifact digest does not match its descriptor");
+		this.#rememberDigest(key);
+		return data;
+	}
+
+	#rememberDigest(key: string): void {
+		this.#verifiedDigests.delete(key);
+		this.#verifiedDigests.set(key, undefined);
+		if (this.#verifiedDigests.size > DIGEST_CACHE_LIMIT) this.#verifiedDigests.delete(this.#verifiedDigests.keys().next().value!);
+	}
 }
diff --git a/packages/host-service/src/image-upload-store.ts b/packages/host-service/src/image-upload-store.ts
index ac39c0a..c9c12dc 100644
--- a/packages/host-service/src/image-upload-store.ts
+++ b/packages/host-service/src/image-upload-store.ts
@@ -16,6 +16,27 @@ const DEFAULT_CONNECTION_BYTES = PROMPT_IMAGE_MAX_COUNT * IMAGE_UPLOAD_MAX_BYTES
 const DEFAULT_GLOBAL_BYTES = 512 * 1024 * 1024;
 const DEFAULT_GLOBAL_UPLOADS = 64;
 
+const STORE_MARKER_NAME = ".t4-image-upload-store";
+const STORE_MARKER_CONTENT = "t4-image-upload-store-v1\n";
+const UPLOAD_FILE_NAME = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+const CLEANUP_FILE_NAME =
+	/^\.delete-[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+const MARKER_TEMP_FILE_NAME =
+	/^\.t4-image-upload-store\.[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.tmp$/iu;
+
+interface DirectoryIdentity {
+	readonly dev: number;
+	readonly ino: number;
+}
+
+function identityOf(info: { readonly dev: number; readonly ino: number }): DirectoryIdentity {
+	return { dev: info.dev, ino: info.ino };
+}
+
+function sameIdentity(left: DirectoryIdentity, right: DirectoryIdentity): boolean {
+	return left.dev === right.dev && left.ino === right.ino;
+}
+
 export class ImageUploadError extends Error {
 	constructor(
 		readonly code:
@@ -42,7 +63,8 @@ export interface ManagedRpcImageRef {
 interface UploadRecord extends ManagedRpcImageRef {
 	readonly connectionId: string;
 	readonly sessionId: SessionId;
-	readonly filePath: string;
+	filePath: string;
+	readonly fileIdentity: DirectoryIdentity;
 	readonly handle: fs.FileHandle;
 	readonly hasher: Hash;
 	received: number;
@@ -111,6 +133,7 @@ export class ImageUploadStore {
 	#timer: NodeJS.Timeout | undefined;
 	#started = false;
 	#tail: Promise<void> = Promise.resolve();
+	#rootIdentity: DirectoryIdentity | undefined;
 
 	constructor(options: ImageUploadStoreOptions) {
 		if (!path.isAbsolute(options.root)) throw new Error("image upload root must be absolute");
@@ -137,9 +160,9 @@ export class ImageUploadStore {
 	async start(): Promise<void> {
 		await this.#run(async () => {
 			if (this.#started) return;
-			await fs.rm(this.root, { recursive: true, force: true });
-			await fs.mkdir(this.root, { mode: 0o700 });
-			await fs.chmod(this.root, 0o700);
+			await this.#prepareRoot();
+			this.#rootIdentity = await this.#ownedRoot();
+			await this.#removeStaleFiles();
 			this.#started = true;
 			this.#timer = setInterval(() => void this.sweepExpired().catch(() => undefined), this.#sweepIntervalMs);
 			this.#timer.unref();
@@ -150,12 +173,18 @@ export class ImageUploadStore {
 		if (this.#timer) clearInterval(this.#timer);
 		this.#timer = undefined;
 		await this.#run(async () => {
-			for (const record of this.#uploads.values()) await this.#remove(record).catch(() => undefined);
-			this.#uploads.clear();
-			this.#reservations.clear();
-			this.#globalBytes = 0;
-			this.#started = false;
-			await fs.rm(this.root, { recursive: true, force: true });
+			try {
+				await this.#ownedRoot();
+				for (const record of this.#uploads.values()) await this.#remove(record);
+				await this.#removeStaleFiles();
+			} finally {
+				for (const record of this.#uploads.values()) await record.handle.close().catch(() => undefined);
+				this.#uploads.clear();
+				this.#reservations.clear();
+				this.#globalBytes = 0;
+				this.#started = false;
+				this.#rootIdentity = undefined;
+			}
 		});
 	}
 
@@ -168,6 +197,7 @@ export class ImageUploadStore {
 	}): Promise<{ imageId: ImageId }> {
 		return this.#run(async () => {
 			this.#assertStarted();
+			await this.#ownedRoot();
 			await this.#sweepExpiredLocked();
 			const reserved = this.#reservations.get(input.connectionId) ?? { bytes: 0, uploads: 0 };
 			if (
@@ -180,8 +210,10 @@ export class ImageUploadStore {
 			const id = imageId(randomUUID());
 			const filePath = path.join(this.root, id);
 			const handle = await fs.open(filePath, "wx+", 0o600);
+			let openedIdentity: DirectoryIdentity | undefined;
 			try {
 				await handle.chmod(0o600);
+				openedIdentity = identityOf(await handle.stat());
 				const record: UploadRecord = {
 					imageId: id,
 					connectionId: input.connectionId,
@@ -191,6 +223,7 @@ export class ImageUploadStore {
 					sha256: input.sha256,
 					filePath,
 					handle,
+					fileIdentity: openedIdentity,
 					hasher: createHash("sha256"),
 					received: 0,
 					updatedAt: this.#now(),
@@ -208,7 +241,11 @@ export class ImageUploadStore {
 				return { imageId: id };
 			} catch (error) {
 				await handle.close().catch(() => undefined);
-				await fs.unlink(filePath).catch(() => undefined);
+				if (openedIdentity !== undefined) {
+					const quarantine = await this.#quarantineFile(filePath, openedIdentity).catch(() => undefined);
+					if (quarantine !== undefined)
+						await this.#unlinkQuarantined(quarantine, openedIdentity).catch(() => undefined);
+				}
 				throw error;
 			}
 		});
@@ -370,12 +407,11 @@ export class ImageUploadStore {
 		if (this.#uploads.get(record.imageId) !== record) return;
 		await record.handle.close().catch(() => undefined);
 		try {
-			await this.#unlink(record.filePath);
+			record.filePath = await this.#quarantineFile(record.filePath, record.fileIdentity);
+			await this.#unlinkQuarantined(record.filePath, record.fileIdentity);
 		} catch (error) {
-			if (!isErrno(error, "ENOENT")) {
-				record.cleanupPending = true;
-				throw error;
-			}
+			record.cleanupPending = true;
+			throw error;
 		}
 		this.#detach(record);
 	}
@@ -391,6 +427,130 @@ export class ImageUploadStore {
 		this.#globalBytes -= record.size;
 	}
 
+	async #prepareRoot(): Promise<void> {
+		let created = false;
+		try {
+			await fs.mkdir(this.root, { mode: 0o700 });
+			created = true;
+		} catch (error) {
+			if (!isErrno(error, "EEXIST")) throw error;
+		}
+		const uid = process.getuid?.();
+		if (uid === undefined) throw new Error("image upload ownership checks are unavailable");
+		if (created) {
+			await fs.chmod(this.root, 0o700);
+		} else {
+			const info = await fs.lstat(this.root);
+			if (
+				info.isSymbolicLink() ||
+				!info.isDirectory() ||
+				info.uid !== uid ||
+				(info.mode & 0o077) !== 0
+			)
+				throw new Error("unmarked image upload root failed ownership validation");
+		}
+		const names = await fs.readdir(this.root);
+		const markerValid = names.includes(STORE_MARKER_NAME) && (await this.#markerIsValid(uid));
+		if (markerValid) return;
+		const unowned = names.filter(name => name !== STORE_MARKER_NAME && !MARKER_TEMP_FILE_NAME.test(name));
+		if (unowned.length > 0) throw new Error("unmarked image upload root is not empty");
+		await this.#installMarker();
+	}
+
+	async #markerIsValid(uid: number): Promise<boolean> {
+		const markerPath = path.join(this.root, STORE_MARKER_NAME);
+		try {
+			const marker = await fs.lstat(markerPath);
+			return (
+				!marker.isSymbolicLink() &&
+				marker.isFile() &&
+				marker.uid === uid &&
+				(marker.mode & 0o022) === 0 &&
+				(await fs.readFile(markerPath, "utf8")) === STORE_MARKER_CONTENT
+			);
+		} catch (error) {
+			if (isErrno(error, "ENOENT")) return false;
+			throw error;
+		}
+	}
+
+	async #installMarker(): Promise<void> {
+		const temporaryPath = path.join(this.root, `${STORE_MARKER_NAME}.${randomUUID()}.tmp`);
+		const markerPath = path.join(this.root, STORE_MARKER_NAME);
+		const handle = await fs.open(temporaryPath, "wx", 0o600);
+		try {
+			await handle.writeFile(STORE_MARKER_CONTENT, "utf8");
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+		await fs.rename(temporaryPath, markerPath);
+	}
+
+	async #ownedFile(filePath: string): Promise<DirectoryIdentity> {
+		const uid = process.getuid?.();
+		if (uid === undefined) throw new Error("image upload ownership checks are unavailable");
+		const info = await fs.lstat(filePath);
+		if (info.isSymbolicLink() || !info.isFile() || info.uid !== uid || (info.mode & 0o022) !== 0)
+			throw new Error("image upload file failed ownership validation");
+		return identityOf(info);
+	}
+
+	async #quarantineFile(filePath: string, expected: DirectoryIdentity): Promise<string> {
+		await this.#ownedRoot();
+		const current = await this.#ownedFile(filePath);
+		if (!sameIdentity(current, expected)) throw new Error("image upload file identity changed");
+		const quarantine = path.join(this.root, `.delete-${randomUUID()}`);
+		await fs.rename(filePath, quarantine);
+		return quarantine;
+	}
+
+	async #unlinkQuarantined(filePath: string, expected: DirectoryIdentity): Promise<void> {
+		await this.#ownedRoot();
+		const current = await this.#ownedFile(filePath);
+		if (!sameIdentity(current, expected)) throw new Error("image upload file identity changed");
+		await this.#unlink(filePath);
+	}
+
+	async #ownedRoot(): Promise<DirectoryIdentity> {
+		const uid = process.getuid?.();
+		if (uid === undefined) throw new Error("image upload ownership checks are unavailable");
+		const info = await fs.lstat(this.root);
+		if (
+			info.isSymbolicLink() ||
+			!info.isDirectory() ||
+			info.uid !== uid ||
+			(info.mode & 0o022) !== 0
+		)
+			throw new Error("image upload root failed ownership validation");
+		const identity = identityOf(info);
+		if (this.#rootIdentity && !sameIdentity(identity, this.#rootIdentity))
+			throw new Error("image upload root identity changed");
+		const markerPath = path.join(this.root, STORE_MARKER_NAME);
+		const marker = await fs.lstat(markerPath);
+		if (marker.isSymbolicLink() || !marker.isFile() || marker.uid !== uid || (marker.mode & 0o022) !== 0)
+			throw new Error("image upload root marker failed validation");
+		if ((await fs.readFile(markerPath, "utf8")) !== STORE_MARKER_CONTENT)
+			throw new Error("image upload root marker is invalid");
+		return identity;
+	}
+
+	async #removeStaleFiles(): Promise<void> {
+		await this.#ownedRoot();
+		const names = (await fs.readdir(this.root)).filter(name => name !== STORE_MARKER_NAME);
+		const stale: { filePath: string; identity: DirectoryIdentity }[] = [];
+		for (const name of names) {
+			if (!UPLOAD_FILE_NAME.test(name) && !CLEANUP_FILE_NAME.test(name) && !MARKER_TEMP_FILE_NAME.test(name))
+				throw new Error("image upload root contains unowned data");
+			const filePath = path.join(this.root, name);
+			stale.push({ filePath, identity: await this.#ownedFile(filePath) });
+		}
+		for (const entry of stale) {
+			const quarantine = await this.#quarantineFile(entry.filePath, entry.identity);
+			await this.#unlinkQuarantined(quarantine, entry.identity);
+		}
+	}
+
 	#assertStarted(): void {
 		if (!this.#started) throw new Error("image upload store is not started");
 	}
diff --git a/packages/host-service/src/operations/dispatcher.ts b/packages/host-service/src/operations/dispatcher.ts
index 6c5c506..67bff9c 100644
--- a/packages/host-service/src/operations/dispatcher.ts
+++ b/packages/host-service/src/operations/dispatcher.ts
@@ -374,10 +374,14 @@ export class DesktopOperationDispatcher implements OperationCommandHandler {
 					sessionId: context.sessionId,
 					terminalId: decoded.terminalId as TerminalId,
 				};
+				let claimed = false;
 				try {
 					this.terminalOwners.claim(owner);
-				} catch (error) {
+					claimed = true;
 					for (const frame of pendingTerminalFrames.splice(0)) this.publishTerminalOutput(frame, owner);
+				} catch (error) {
+					pendingTerminalFrames.length = 0;
+					if (claimed) this.terminalOwners.release(owner.terminalId);
 					if (this.authority.terminalClose)
 						await this.authority.terminalClose(
 							{
diff --git a/packages/host-service/src/server.ts b/packages/host-service/src/server.ts
index 158f39a..15523aa 100644
--- a/packages/host-service/src/server.ts
+++ b/packages/host-service/src/server.ts
@@ -756,6 +756,8 @@ export class LocalAppserver implements AppserverHandle {
 	#projections = new Map<SessionId, SessionProjection>();
 	#supervisors = new Map<SessionId, RpcChildSupervisor>();
 	#externalRuntimes = new Map<SessionId, ExternalRuntimeOwner>();
+	readonly #openingExternalRuntimes = new Map<string, number>();
+	readonly #archivingWorkspaces = new Set<string>();
 	#externalPermissions = new Map<SessionId, Map<string, ExternalPermissionRequest>>();
 	#externalTurns = new Map<SessionId, ExternalTurnProjection>();
 	#promptLifecycles = new Map<SessionId, PromptLifecycle>();
@@ -2179,6 +2181,9 @@ export class LocalAppserver implements AppserverHandle {
 		if (workspace.lifecycle !== "active") throw new Error("workspace is not active");
 		if (workspace.repositoryId !== requestedProject)
 			throw new Error("workspace does not belong to the requested project");
+		if (this.#archivingWorkspaces.has(workspace.instanceId))
+			throw new Error("workspace is being archived");
+		this.#reserveExternalRuntimeOpening(workspace.instanceId);
 		const publicSessionId = sessionId(`session-${randomUUID()}`);
 		const runtimeWorkspace: RuntimeWorkspaceIdentity = {
 			instanceId: workspace.instanceId,
@@ -2217,9 +2222,30 @@ export class LocalAppserver implements AppserverHandle {
 			this.#records.delete(publicSessionId);
 			this.#projections.delete(publicSessionId);
 			throw cause;
+		} finally {
+			this.#releaseExternalRuntimeOpening(workspace.instanceId);
 		}
 	}
 
+	#reserveExternalRuntimeOpening(workspaceInstanceId: string): void {
+		this.#openingExternalRuntimes.set(
+			workspaceInstanceId,
+			(this.#openingExternalRuntimes.get(workspaceInstanceId) ?? 0) + 1,
+		);
+	}
+
+	#releaseExternalRuntimeOpening(workspaceInstanceId: string): void {
+		const openings = this.#openingExternalRuntimes.get(workspaceInstanceId);
+		if (openings === undefined || openings <= 1) this.#openingExternalRuntimes.delete(workspaceInstanceId);
+		else this.#openingExternalRuntimes.set(workspaceInstanceId, openings - 1);
+	}
+
+	#workspaceHasExternalRuntimeOwner(workspaceInstanceId: string): boolean {
+		return (
+			this.#openingExternalRuntimes.has(workspaceInstanceId) ||
+			[...this.#externalRuntimes.values()].some(owner => owner.workspaceInstanceId === workspaceInstanceId)
+		);
+	}
 	private appendExternalEntry(
 		sessionId: SessionId,
 		kind: string,
@@ -2583,11 +2609,30 @@ export class LocalAppserver implements AppserverHandle {
 		});
 	}
 	private handleWorkspaceArchive(command: CommandFrame): Promise<CommandOutcome> {
-		return this.workspaceCommand(command, async () => ({
-			workspace: this.workspaceProjection(
-				await this.#workspaceAuthority!.archive({ instanceId: command.args.instanceId as string }),
-			),
-		}));
+		return this.workspaceCommand(command, async () => {
+			const instanceId = command.args.instanceId as string;
+			const authority = this.#workspaceAuthority!;
+			const workspace = authority.get(instanceId);
+			if (!workspace) throw new WorkspaceAuthorityError("worktree-not-found", "Workspace record was not found");
+			if (workspace.ownership === "repository-root")
+				throw new WorkspaceAuthorityError("repository-root-protected", "Repository root worktrees cannot be archived");
+			if (workspace.ownership !== "managed")
+				throw new WorkspaceAuthorityError(
+					"ownership-protected",
+					"Imported and detected worktrees are never deleted by the authority",
+				);
+			if (this.#archivingWorkspaces.has(instanceId))
+				throw new WorkspaceAuthorityError("mutation-in-progress", "Workspace archive is already in progress");
+			if (this.#workspaceHasExternalRuntimeOwner(instanceId))
+				throw new WorkspaceAuthorityError("mutation-in-progress", "Workspace is owned by a live external runtime");
+			this.#archivingWorkspaces.add(instanceId);
+			try {
+				const sealed = await authority.seal({ instanceId });
+				return { workspace: this.workspaceProjection(await authority.archive({ instanceId: sealed.instanceId })) };
+			} finally {
+				this.#archivingWorkspaces.delete(instanceId);
+			}
+		});
 	}
 	private handleWorkspaceRecover(command: CommandFrame): Promise<CommandOutcome> {
 		return this.workspaceCommand(command, async () => ({
diff --git a/packages/host-service/test/artifact-reader.test.ts b/packages/host-service/test/artifact-reader.test.ts
index 8ad5ba0..1b0aec1 100644
--- a/packages/host-service/test/artifact-reader.test.ts
+++ b/packages/host-service/test/artifact-reader.test.ts
@@ -1,28 +1,28 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, spyOn, test } from "bun:test";
 import { createHash } from "node:crypto";
-import { chmod, mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
+import * as fs from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { type ArtifactDescriptor, artifactId } from "@t4-code/host-wire";
+import { ARTIFACT_CHUNK_BYTES, type ArtifactDescriptor, artifactId } from "@t4-code/host-wire";
 import { ArtifactReadError, ArtifactReader } from "../src/artifact-reader";
 
 const roots: string[] = [];
 
 afterEach(async () => {
-	while (roots.length > 0) await rm(roots.pop()!, { recursive: true, force: true });
+	while (roots.length > 0) await fs.rm(roots.pop()!, { recursive: true, force: true });
 });
 
-async function fixture(): Promise<{
+async function fixture(bytes = Buffer.from("bounded artifact bytes")): Promise<{
 	root: string;
 	content: Buffer;
 	descriptor: ArtifactDescriptor;
 }> {
-	const root = await mkdtemp(join(tmpdir(), "omp-artifact-reader-test-"));
+	const root = await fs.mkdtemp(join(tmpdir(), "omp-artifact-reader-test-"));
 	roots.push(root);
-	await chmod(root, 0o700);
-	const content = Buffer.from("bounded artifact bytes");
+	await fs.chmod(root, 0o700);
+	const content = Buffer.from(bytes);
 	const name = "2001.tool.log";
-	await writeFile(join(root, name), content, { mode: 0o600 });
+	await fs.writeFile(join(root, name), content, { mode: 0o600 });
 	return {
 		root,
 		content,
@@ -62,8 +62,8 @@ describe("ArtifactReader", () => {
 		await expect(reader.read(root, { ...descriptor, name: "2001.other.log" }, 0)).rejects.toMatchObject({
 			code: "artifact_invalid",
 		});
-		await rm(join(root, descriptor.name!));
-		await symlink("missing", join(root, descriptor.name!));
+		await fs.rm(join(root, descriptor.name!));
+		await fs.symlink("missing", join(root, descriptor.name!));
 		await expect(reader.read(root, descriptor, 0)).rejects.toBeInstanceOf(ArtifactReadError);
 		const controller = new AbortController();
 		controller.abort();
@@ -71,4 +71,38 @@ describe("ArtifactReader", () => {
 			code: "connection_closed",
 		});
 	});
+
+	test("hashes a stable descriptor through its opened handle and reuses that verification across chunks", async () => {
+		const content = Buffer.alloc(ARTIFACT_CHUNK_BYTES * 2 + 37, 0x61);
+		const { root, descriptor } = await fixture(content);
+		const readFile = spyOn(fs, "readFile");
+		try {
+			const reader = new ArtifactReader();
+			await expect(reader.read(root, { ...descriptor, sha256: "0".repeat(64) }, 0)).rejects.toMatchObject({
+				code: "artifact_invalid",
+			});
+			expect((await reader.read(root, descriptor, 0)).content).toBe(
+				content.subarray(0, ARTIFACT_CHUNK_BYTES).toString("base64"),
+			);
+			expect((await reader.read(root, descriptor, ARTIFACT_CHUNK_BYTES)).content).toBe(
+				content.subarray(ARTIFACT_CHUNK_BYTES, ARTIFACT_CHUNK_BYTES * 2).toString("base64"),
+			);
+			expect(readFile).not.toHaveBeenCalled();
+		} finally {
+			readFile.mockRestore();
+		}
+	});
+
+	test("invalidates verified digests when an artifact mutates or is replaced", async () => {
+		const content = Buffer.alloc(ARTIFACT_CHUNK_BYTES + 37, 0x61);
+		const { root, descriptor } = await fixture(content);
+		const reader = new ArtifactReader();
+		const artifactPath = join(root, descriptor.name!);
+		await reader.read(root, descriptor, 0);
+		await fs.writeFile(artifactPath, Buffer.alloc(content.byteLength, 0x62), { mode: 0o600 });
+		await expect(reader.read(root, descriptor, 0)).rejects.toMatchObject({ code: "artifact_invalid" });
+		await fs.writeFile(join(root, "replacement"), Buffer.alloc(content.byteLength, 0x63), { mode: 0o600 });
+		await fs.rename(join(root, "replacement"), artifactPath);
+		await expect(reader.read(root, descriptor, 0)).rejects.toMatchObject({ code: "artifact_invalid" });
+	});
 });
diff --git a/packages/host-service/test/image-upload-store.test.ts b/packages/host-service/test/image-upload-store.test.ts
index 4bbcfcc..f4e8b31 100644
--- a/packages/host-service/test/image-upload-store.test.ts
+++ b/packages/host-service/test/image-upload-store.test.ts
@@ -221,7 +221,7 @@ describe("managed appserver image uploads", () => {
 			const started = await store.begin(input);
 
 			await expect(store.cleanupConnection(input.connectionId)).resolves.toBeUndefined();
-			expect(await fs.stat(path.join(root, started.imageId))).toBeDefined();
+			expect((await fs.readdir(root)).filter(name => name.startsWith(".delete-"))).toHaveLength(1);
 			await expect(
 				store.chunk({
 					connectionId: input.connectionId,
@@ -235,7 +235,7 @@ describe("managed appserver image uploads", () => {
 
 			failUnlink = false;
 			await store.sweepExpired();
-			await expect(fs.stat(path.join(root, started.imageId))).rejects.toMatchObject({ code: "ENOENT" });
+			expect((await fs.readdir(root)).filter(name => name.startsWith(".delete-"))).toHaveLength(0);
 			expect(await store.begin(input)).toHaveProperty("imageId");
 		} finally {
 			await store.stop();
@@ -275,11 +275,11 @@ describe("managed appserver image uploads", () => {
 			// failure while retaining its reservation for a safe retry.
 			await expect(store.release(acknowledged)).resolves.toBeUndefined();
 			await expect(store.begin(input)).rejects.toMatchObject({ code: "image_quota_exceeded" });
-			expect(await fs.stat(path.join(root, started.imageId))).toBeDefined();
+			expect((await fs.readdir(root)).filter(name => name.startsWith(".delete-"))).toHaveLength(1);
 
 			failUnlink = false;
 			await store.sweepExpired();
-			await expect(fs.stat(path.join(root, started.imageId))).rejects.toMatchObject({ code: "ENOENT" });
+			expect((await fs.readdir(root)).filter(name => name.startsWith(".delete-"))).toHaveLength(0);
 			expect(await store.begin(input)).toHaveProperty("imageId");
 		} finally {
 			await store.stop();
@@ -324,4 +324,187 @@ describe("managed appserver image uploads", () => {
 			await fs.rm(parent, { recursive: true, force: true });
 		}
 	});
+
+	test("claims an empty private preexisting root", async () => {
+		const parent = await fs.mkdtemp(path.join(os.tmpdir(), "omp-image-store-empty-"));
+		const root = path.join(parent, "images");
+		await fs.mkdir(root, { mode: 0o700 });
+		const store = new ImageUploadStore({ root, sweepIntervalMs: 60_000 });
+		try {
+			await store.start();
+			expect(await fs.readdir(root)).toEqual([".t4-image-upload-store"]);
+			await store.stop();
+		} finally {
+			await fs.rm(parent, { recursive: true, force: true });
+		}
+	});
+
+	test("repairs an interrupted marker when no unrelated data is present", async () => {
+		const parent = await fs.mkdtemp(path.join(os.tmpdir(), "omp-image-store-marker-"));
+		const root = path.join(parent, "images");
+		await fs.mkdir(root, { mode: 0o700 });
+		await fs.writeFile(path.join(root, ".t4-image-upload-store"), "partial", { mode: 0o600 });
+		const store = new ImageUploadStore({ root, sweepIntervalMs: 60_000 });
+		try {
+			await store.start();
+			expect(await fs.readFile(path.join(root, ".t4-image-upload-store"), "utf8")).toBe(
+				"t4-image-upload-store-v1\n",
+			);
+			await store.stop();
+		} finally {
+			await fs.rm(parent, { recursive: true, force: true });
+		}
+	});
+
+	test("refuses unproven preexisting roots without deleting their contents", async () => {
+		const parent = await fs.mkdtemp(path.join(os.tmpdir(), "omp-image-store-unproven-"));
+		const root = path.join(parent, "images");
+		const sentinel = path.join(root, "sentinel");
+		await fs.mkdir(root, { mode: 0o700 });
+		await fs.writeFile(sentinel, "preserve me");
+		try {
+			const store = new ImageUploadStore({ root, sweepIntervalMs: 60_000 });
+			await expect(store.start()).rejects.toThrow();
+			expect(await fs.readFile(sentinel, "utf8")).toBe("preserve me");
+		} finally {
+			await fs.rm(parent, { recursive: true, force: true });
+		}
+	});
+
+	test("recovers only stale files from a valid owned spool", async () => {
+		const { parent, root, store } = await testStore();
+		const stale = path.join(root, "4e2e669a-5f8e-44a3-b702-e725c4c106c8");
+		const interrupted = path.join(root, ".delete-7c4476e9-b9e3-471c-8b2b-2a9f3e86bd2f");
+		const markerTemp = path.join(
+			root,
+			".t4-image-upload-store.1d816c9f-2aba-448f-a38b-4c537f99760f.tmp",
+		);
+		try {
+			await store.stop();
+			await fs.writeFile(stale, "stale");
+			await fs.writeFile(interrupted, "interrupted");
+			await fs.writeFile(markerTemp, "partial marker");
+			const recovered = new ImageUploadStore({ root, sweepIntervalMs: 60_000 });
+			await recovered.start();
+			await expect(fs.stat(stale)).rejects.toMatchObject({ code: "ENOENT" });
+			await expect(fs.stat(interrupted)).rejects.toMatchObject({ code: "ENOENT" });
+			await expect(fs.stat(markerTemp)).rejects.toMatchObject({ code: "ENOENT" });
+			await recovered.stop();
+		} finally {
+			await fs.rm(parent, { recursive: true, force: true });
+		}
+	});
+
+	test("does not remove a replacement upload file", async () => {
+		const { parent, root, store } = await testStore();
+		const displaced = path.join(parent, "displaced-upload");
+		try {
+			const input = {
+				connectionId: "connection-a",
+				sessionId: sessionId("session-a"),
+				mimeType: "image/png" as const,
+				size: png.byteLength,
+				sha256: digest(png),
+			};
+			const started = await store.begin(input);
+			const uploadPath = path.join(root, started.imageId);
+			await fs.rename(uploadPath, displaced);
+			await fs.writeFile(uploadPath, "foreign data", { mode: 0o600 });
+			await expect(store.discard(input.connectionId, input.sessionId, started.imageId)).rejects.toThrow(
+				"identity changed",
+			);
+			expect(await fs.readFile(uploadPath, "utf8")).toBe("foreign data");
+			await expect(store.stop()).rejects.toThrow("identity changed");
+		} finally {
+			await fs.rm(parent, { recursive: true, force: true });
+		}
+	});
+
+	test("does not report deletion after the quarantined file moves", async () => {
+		const parent = await fs.mkdtemp(path.join(os.tmpdir(), "omp-image-store-moved-"));
+		const root = path.join(parent, "images");
+		const displaced = path.join(parent, "displaced-upload");
+		const store = new ImageUploadStore({
+			root,
+			sweepIntervalMs: 60_000,
+			unlink: async filePath => {
+				await fs.rename(filePath, displaced);
+				await fs.unlink(filePath);
+			},
+		});
+		try {
+			await store.start();
+			const input = {
+				connectionId: "connection-a",
+				sessionId: sessionId("session-a"),
+				mimeType: "image/png" as const,
+				size: png.byteLength,
+				sha256: digest(png),
+			};
+			const started = await store.begin(input);
+			await store.chunk({ ...input, imageId: started.imageId, offset: 0, data: png });
+			await expect(
+				store.discard(input.connectionId, input.sessionId, started.imageId),
+			).rejects.toMatchObject({ code: "ENOENT" });
+			expect(await fs.readFile(displaced)).toEqual(Buffer.from(png));
+			await expect(store.stop()).rejects.toMatchObject({ code: "ENOENT" });
+		} finally {
+			await fs.rm(parent, { recursive: true, force: true });
+		}
+	});
+
+	test("does not unlink through a replacement root", async () => {
+		const parent = await fs.mkdtemp(path.join(os.tmpdir(), "omp-image-store-replaced-"));
+		const root = path.join(parent, "images");
+		const displaced = path.join(parent, "displaced");
+		const sentinel = path.join(root, "replacement-sentinel");
+		let replaceOnUnlink = true;
+		const store = new ImageUploadStore({
+			root,
+			sweepIntervalMs: 60_000,
+			unlink: async filePath => {
+				if (replaceOnUnlink) {
+					replaceOnUnlink = false;
+					await fs.rename(root, displaced);
+					await fs.mkdir(root, { mode: 0o700 });
+					await fs.writeFile(sentinel, "foreign data");
+				}
+				await fs.unlink(filePath);
+			},
+		});
+		try {
+			await store.start();
+			const input = {
+				connectionId: "connection-a",
+				sessionId: sessionId("session-a"),
+				mimeType: "image/png" as const,
+				size: png.byteLength,
+				sha256: digest(png),
+			};
+			const started = await store.begin(input);
+			await expect(
+				store.discard(input.connectionId, input.sessionId, started.imageId),
+			).rejects.toMatchObject({ code: "ENOENT" });
+			expect(await fs.readFile(sentinel, "utf8")).toBe("foreign data");
+			expect((await fs.readdir(displaced)).filter(name => name.startsWith(".delete-"))).toHaveLength(1);
+			await expect(store.stop()).rejects.toThrow("identity changed");
+		} finally {
+			await fs.rm(parent, { recursive: true, force: true });
+		}
+	});
+
+	test("fails closed when the owned root is replaced during teardown", async () => {
+		const { parent, root, store } = await testStore();
+		const displaced = path.join(parent, "displaced");
+		const sentinel = path.join(root, "replacement-sentinel");
+		try {
+			await fs.rename(root, displaced);
+			await fs.mkdir(root, { mode: 0o700 });
+			await fs.writeFile(sentinel, "foreign data");
+			await expect(store.stop()).rejects.toThrow("identity changed");
+			expect(await fs.readFile(sentinel, "utf8")).toBe("foreign data");
+		} finally {
+			await fs.rm(parent, { recursive: true, force: true });
+		}
+	});
 });
diff --git a/packages/host-service/test/operations.test.ts b/packages/host-service/test/operations.test.ts
index 156420a..07ad419 100644
--- a/packages/host-service/test/operations.test.ts
+++ b/packages/host-service/test/operations.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, spyOn, test } from "bun:test";
 import {
 	COMMAND_DESCRIPTORS,
 	commandId,
@@ -298,6 +298,94 @@ describe("desktop operation dispatcher", () => {
 			),
 		).not.toThrow();
 	});
+
+	test("flushes synchronous terminal output exactly once after claiming its owner", async () => {
+		let authorityOutputs = 0;
+		let forwardedOutputs = 0;
+		const dispatcher = new DesktopOperationDispatcher(
+			authority({
+				termOpen: async (_args, operationContext) => {
+					operationContext.emitTerminalOutput?.({
+						v: "omp-app/1",
+						type: "terminal.output",
+						hostId: context.hostId,
+						sessionId: context.sessionId,
+						terminalId: terminalId("term-1"),
+						cursor: { epoch: "e", seq: 1 },
+						stream: "stdout",
+						data: "synchronous",
+					});
+					return { terminalId: "term-1" };
+				},
+				terminalOutput: () => {
+					authorityOutputs++;
+				},
+			}),
+			undefined,
+			() => {
+				forwardedOutputs++;
+			},
+		);
+		await dispatcher.dispatch(command("term.open"), context);
+		expect(authorityOutputs).toBe(1);
+		expect(forwardedOutputs).toBe(1);
+	});
+
+	test("discards synchronous output when a terminal owner claim conflicts", async () => {
+		const owners = new TerminalOwnerRegistry();
+		owners.claim({
+			connectionId: "other-connection",
+			deviceId: "other-device",
+			hostId: context.hostId,
+			sessionId: context.sessionId!,
+			terminalId: terminalId("term-1"),
+		});
+		let closes = 0;
+		const dispatcher = new DesktopOperationDispatcher(
+			authority({
+				termOpen: async (_args, operationContext) => {
+					operationContext.emitTerminalOutput?.({
+						v: "omp-app/1",
+						type: "terminal.output",
+						hostId: context.hostId,
+						sessionId: context.sessionId,
+						terminalId: terminalId("term-1"),
+						cursor: { epoch: "e", seq: 1 },
+						stream: "stdout",
+						data: "discard",
+					});
+					return { terminalId: "term-1" };
+				},
+				terminalClose: async () => {
+					closes++;
+				},
+			}),
+			owners,
+		);
+		const publish = spyOn(dispatcher, "publishTerminalOutput");
+		await expect(dispatcher.dispatch(command("term.open"), context)).rejects.toMatchObject({ code: "FORBIDDEN" });
+		expect(publish).not.toHaveBeenCalled();
+		expect(closes).toBe(1);
+	});
+
+	test("releases a claimed terminal owner when buffered output is invalid", async () => {
+		let closes = 0;
+		const dispatcher = new DesktopOperationDispatcher(
+			authority({
+				termOpen: async (_args, operationContext) => {
+					operationContext.emitTerminalOutput?.({ type: "invalid-terminal-frame" });
+					return { terminalId: "term-1" };
+				},
+				terminalClose: async () => {
+					closes++;
+				},
+			}),
+		);
+		await expect(dispatcher.dispatch(command("term.open"), context)).rejects.toBeDefined();
+		expect(dispatcher.hasOpenTerminals(context.sessionId!)).toBe(false);
+		expect(closes).toBe(1);
+	});
+
 	test("authority receives unchanged revision and abort signal", async () => {
 		let seen: OperationContext | undefined;
 		const dispatcher = new DesktopOperationDispatcher(
diff --git a/packages/host-service/test/runtime-workspace-server.test.ts b/packages/host-service/test/runtime-workspace-server.test.ts
index a08e737..bb1f15d 100644
--- a/packages/host-service/test/runtime-workspace-server.test.ts
+++ b/packages/host-service/test/runtime-workspace-server.test.ts
@@ -20,6 +20,27 @@ async function git(cwd: string, ...arguments_: string[]): Promise<void> {
 	if (exitCode !== 0) throw new Error(stderr || stdout);
 }
 
+async function gitOutput(cwd: string, ...arguments_: string[]): Promise<string> {
+	const child = Bun.spawn(["git", "-C", cwd, ...arguments_], { stdout: "pipe", stderr: "pipe" });
+	const [exitCode, stdout, stderr] = await Promise.all([
+		child.exited,
+		new Response(child.stdout).text(),
+		new Response(child.stderr).text(),
+	]);
+	if (exitCode !== 0) throw new Error(stderr || stdout);
+	return stdout.trim();
+}
+
+async function runProcess(command: string, arguments_: readonly string[]) {
+	const child = Bun.spawn([command, ...arguments_], { stdout: "pipe", stderr: "pipe" });
+	const [exitCode, stdout, stderr] = await Promise.all([
+		child.exited,
+		new Response(child.stdout).text(),
+		new Response(child.stderr).text(),
+	]);
+	return { exitCode, stdout, stderr };
+}
+
 function hello(): Record<string, unknown> {
 	return {
 		v: "omp-app/1",
@@ -53,7 +74,6 @@ async function response(
 		if (frame.type === "response" && frame.requestId === requestId) return frame;
 	}
 }
-
 async function sessionEvent(client: RawUdsWebSocket, type: string): Promise<Record<string, unknown>> {
 	for (;;) {
 		const frame = await client.nextServer();
@@ -64,7 +84,7 @@ async function sessionEvent(client: RawUdsWebSocket, type: string): Promise<Reco
 async function approveChallenge(
 	client: RawUdsWebSocket,
 	requestId: string,
-	sessionId: string,
+	sessionId?: string,
 ): Promise<Extract<ServerFrame, { type: "response" }>> {
 	for (;;) {
 		const frame = await client.nextServer();
@@ -76,13 +96,30 @@ async function approveChallenge(
 			confirmationId: frame.confirmationId,
 			commandId: requestId,
 			hostId: host,
-			sessionId,
+			...(sessionId ? { sessionId } : {}),
 			decision: "approve",
 		});
 		return response(client, requestId);
 	}
 }
 
+async function approveChallengeAndContinue(client: RawUdsWebSocket, requestId: string): Promise<void> {
+	for (;;) {
+		const frame = await client.nextServer();
+		if (frame.type !== "confirmation" || frame.commandId !== requestId) continue;
+		client.sendJson({
+			v: "omp-app/1",
+			type: "confirm",
+			requestId: `${requestId}-confirm`,
+			confirmationId: frame.confirmationId,
+			commandId: requestId,
+			hostId: host,
+			decision: "approve",
+		});
+		return;
+	}
+}
+
 test("negotiates and serves runtime and workspace authority commands", async () => {
 	const root = await realpath(await mkdtemp(join(tmpdir(), "omp-authority-wire-")));
 	const workspaceAuthority = await WorkspaceAuthority.open({ databasePath: join(root, "workspaces.sqlite") });
@@ -94,12 +131,20 @@ test("negotiates and serves runtime and workspace authority commands", async ()
 	await writeFile(join(repository, "README.md"), "fixture\n");
 	await git(repository, "add", "README.md");
 	await git(repository, "commit", "-qm", "fixture");
-	await workspaceAuthority.import({
+	const rootWorkspace = await workspaceAuthority.import({
 		repositoryId: "project-wire",
 		repositoryPath: repository,
 		workspacePath: repository,
 		ownership: "repository-root",
 	});
+	const importedPath = join(root, "imported-workspace");
+	await git(repository, "worktree", "add", "-b", "external/imported", importedPath, "HEAD");
+	const importedWorkspace = await workspaceAuthority.import({
+		repositoryId: "project-wire",
+		repositoryPath: repository,
+		workspacePath: importedPath,
+		ownership: "imported-user",
+	});
 	const runtimes = new RuntimeAdapterRegistry({
 		executableAvailable: executable => {
 			if (executable === "broken-runtime") throw new Error("probe failed");
@@ -163,15 +208,43 @@ test("negotiates and serves runtime and workspace authority commands", async ()
 
 		client.sendJson(command("workspace-list", "workspace.list"));
 		const workspaceList = await response(client, "workspace-list");
-		expect(workspaceList).toMatchObject({
-			ok: true,
-			result: { workspaces: [{ repositoryId: "project-wire", ownership: "repository-root" }] },
-		});
-		const projectedWorkspace = (workspaceList.result as { workspaces: Array<Record<string, unknown>> })
-			.workspaces[0]!;
+		const workspaceResult = workspaceList.result;
+		if (
+			!workspaceResult ||
+			typeof workspaceResult !== "object" ||
+			!("workspaces" in workspaceResult) ||
+			!Array.isArray(workspaceResult.workspaces)
+		)
+			throw new Error("workspace list result is invalid");
+		const workspaces = workspaceResult.workspaces;
+		expect(workspaces).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ repositoryId: "project-wire", ownership: "repository-root" }),
+				expect.objectContaining({ repositoryId: "project-wire", ownership: "imported-user" }),
+			]),
+		);
+		const projectedWorkspace = workspaces[0]!;
 		expect(projectedWorkspace).not.toHaveProperty("repositoryRoot");
 		expect(projectedWorkspace).not.toHaveProperty("canonicalPath");
 		expect(projectedWorkspace).not.toHaveProperty("recoveryDiagnostic");
+		await writeFile(join(repository, "advanced.txt"), "would seal if unprotected\n");
+		await git(repository, "add", "advanced.txt");
+		await git(repository, "commit", "-qm", "advance protected workspace");
+		client.sendJson(command("archive-protected", "workspace.archive", { instanceId: rootWorkspace.instanceId }));
+		expect(await approveChallenge(client, "archive-protected")).toMatchObject({
+			ok: false,
+			error: { code: "repository-root-protected" },
+		});
+		expect(workspaceAuthority.get(rootWorkspace.instanceId)?.expectedHead).toBe(rootWorkspace.expectedHead);
+		await writeFile(join(importedPath, "advanced.txt"), "would seal if imported\n");
+		await git(importedPath, "add", "advanced.txt");
+		await git(importedPath, "commit", "-qm", "advance imported workspace");
+		client.sendJson(command("archive-imported", "workspace.archive", { instanceId: importedWorkspace.instanceId }));
+		expect(await approveChallenge(client, "archive-imported")).toMatchObject({
+			ok: false,
+			error: { code: "ownership-protected" },
+		});
+		expect(workspaceAuthority.get(importedWorkspace.instanceId)?.expectedHead).toBe(importedWorkspace.expectedHead);
 
 		client.sendJson(command("workspace-recover", "workspace.recover"));
 		expect(await response(client, "workspace-recover")).toMatchObject({ ok: true, result: { workspaces: [] } });
@@ -224,7 +297,21 @@ test("runs owner initialization only after exclusive appserver ownership", async
 
 test("routes an external runtime session through appserver-owned workspace identity", async () => {
 	const root = await realpath(await mkdtemp(join(tmpdir(), "omp-external-runtime-wire-")));
-	const workspaceAuthority = await WorkspaceAuthority.open({ databasePath: join(root, "workspaces.sqlite") });
+	const archiveEntered = Promise.withResolvers<void>();
+	const archiveRelease = Promise.withResolvers<void>();
+	let holdArchive = false;
+	const workspaceAuthority = await WorkspaceAuthority.open({
+		databasePath: join(root, "workspaces.sqlite"),
+		process: {
+			async run(command, arguments_) {
+				if (holdArchive && command === "git" && arguments_.includes("status")) {
+					archiveEntered.resolve();
+					await archiveRelease.promise;
+				}
+				return runProcess(command, arguments_);
+			},
+		},
+	});
 	const repository = join(root, "repository");
 	await mkdir(repository);
 	await git(repository, "init", "-q");
@@ -233,18 +320,22 @@ test("routes an external runtime session through appserver-owned workspace ident
 	await writeFile(join(repository, "README.md"), "fixture\n");
 	await git(repository, "add", "README.md");
 	await git(repository, "commit", "-qm", "fixture");
-	const workspace = await workspaceAuthority.import({
+	const workspace = await workspaceAuthority.create({
 		repositoryId: "project-external",
 		repositoryPath: repository,
-		workspacePath: repository,
-		ownership: "repository-root",
+		targetPath: join(root, "external-workspace"),
+		branch: "agent/external-runtime",
+		sourceCommit: await gitOutput(repository, "rev-parse", "HEAD"),
 	});
 	const promptEntered = Promise.withResolvers<void>();
 	const promptRelease = Promise.withResolvers<void>();
+	const openingEntered = Promise.withResolvers<void>();
+	const openingRelease = Promise.withResolvers<void>();
 	const permissionEntered = Promise.withResolvers<void>();
 	let permissionSelection: unknown;
 	let promptCount = 0;
 	let callbacks: RuntimeAdapterCallbacks | undefined;
+	let openings = 0;
 	let openedCwd: string | undefined;
 	let prompted: string | undefined;
 	let cancelled = 0;
@@ -258,8 +349,11 @@ test("routes an external runtime session through appserver-owned workspace ident
 			capabilities: { prompt: "native", cancel: "native" },
 		},
 		async openSession(request) {
+			openings++;
 			callbacks = request.callbacks;
 			openedCwd = request.workspace.cwd;
+			openingEntered.resolve();
+			await openingRelease.promise;
 			return {
 				adapterId: "test-runtime",
 				sessionId: "provider-private-session",
@@ -348,6 +442,13 @@ test("routes an external runtime session through appserver-owned workspace ident
 				title: "External session",
 			}),
 		);
+		await openingEntered.promise;
+		client.sendJson(command("archive-during-open", "workspace.archive", { instanceId: workspace.instanceId }));
+		expect(await approveChallenge(client, "archive-during-open")).toMatchObject({
+			ok: false,
+			error: { code: "mutation-in-progress" },
+		});
+		openingRelease.resolve();
 		const created = await response(client, "create-external");
 		expect(created).toMatchObject({
 			ok: true,
@@ -359,9 +460,13 @@ test("routes an external runtime session through appserver-owned workspace ident
 			},
 		});
 		expect(JSON.stringify(created)).not.toContain(repository);
-		expect(JSON.stringify(created)).not.toContain("provider-private-session");
-		expect(openedCwd).toBe(repository);
+		expect(openedCwd).toBe(workspace.canonicalPath);
 		const publicSessionId = (created.result as { session: { sessionId: string } }).session.sessionId;
+		client.sendJson(command("archive-live-runtime", "workspace.archive", { instanceId: workspace.instanceId }));
+		expect(await approveChallenge(client, "archive-live-runtime")).toMatchObject({
+			ok: false,
+			error: { code: "mutation-in-progress" },
+		});
 		const sessionCommand = (requestId: string, name: string, args: Record<string, unknown> = {}) => ({
 			...command(requestId, name, args),
 			sessionId: publicSessionId,
@@ -429,8 +534,32 @@ test("routes an external runtime session through appserver-owned workspace ident
 			result: { closed: true },
 		});
 		expect(disposed).toBe(1);
+		await writeFile(join(workspace.canonicalPath, "fast-forward.txt"), "sealed before archive\n");
+		await git(workspace.canonicalPath, "add", "fast-forward.txt");
+		await git(workspace.canonicalPath, "commit", "-qm", "fast forward");
+		holdArchive = true;
+		client.sendJson(command("archive-quiescent-runtime", "workspace.archive", { instanceId: workspace.instanceId }));
+		await approveChallengeAndContinue(client, "archive-quiescent-runtime");
+		await archiveEntered.promise;
+		client.sendJson(
+			command("create-during-archive", "session.create", {
+				projectId: "project-external",
+				runtimeId: "test-runtime",
+				workspaceInstanceId: workspace.instanceId,
+				title: "Rejected while archiving",
+			}),
+		);
+		expect(await response(client, "create-during-archive")).toMatchObject({ ok: false });
+		expect(openings).toBe(1);
+		archiveRelease.resolve();
+		expect(await response(client, "archive-quiescent-runtime")).toMatchObject({
+			ok: true,
+			result: { workspace: { instanceId: workspace.instanceId, lifecycle: "archived" } },
+		});
 	} finally {
 		promptRelease.resolve();
+		openingRelease.resolve();
+		archiveRelease.resolve();
 		client?.destroy();
 		if (client) await client.closed();
 		await appserver.stop();
diff --git a/scripts/check-release-consistency.mjs b/scripts/check-release-consistency.mjs
index 86a2d7b..088a953 100644
--- a/scripts/check-release-consistency.mjs
+++ b/scripts/check-release-consistency.mjs
@@ -2,6 +2,7 @@ import { readFileSync, readdirSync } from "node:fs";
 import { resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { fileURLToPath } from "node:url";
+import { load as parseYaml } from "js-yaml";
 
 export const RELEASE_CONTRACT_PATHS = [
   ".github/android-release-identity.json",
@@ -743,14 +744,79 @@ export function collectReleaseConsistencyErrors(files, releaseTag) {
 
   const releaseWorkflow = files.get(".github/workflows/release.yml") ?? "";
   const ciWorkflow = files.get(".github/workflows/ci.yml") ?? "";
+  try {
+    const workflow = parseYaml(ciWorkflow);
+    const continuityJob = workflow?.jobs?.["legacy-bridge-continuity"];
+    if (!continuityJob || !Array.isArray(continuityJob.steps)) {
+      errors.push(".github/workflows/ci.yml is missing the legacy-bridge-continuity job");
+    } else {
+      const namedStep = (name) => {
+        const matches = continuityJob.steps.filter((step) => step?.name === name);
+        if (matches.length !== 1) {
+          errors.push(`.github/workflows/ci.yml must contain exactly one ${JSON.stringify(name)} step`);
+          return undefined;
+        }
+        return matches[0];
+      };
+      const authorityStep = namedStep("Resolve pinned OMP authority source");
+      const checkoutStep = namedStep("Check out pinned OMP authority source");
+      const continuityStep = namedStep("Run legacy bridge continuity gate");
+      const uploadStep = namedStep("Upload continuity evidence");
+      const authorityCommands = [
+        `source_repository="$(jq -er '.sourceRepository' provenance/omp-host-migration.json)"`,
+        `test "$source_repository" = "https://github.com/lyc-aon/oh-my-pi"`,
+        `sha="$(jq -er '.inputs.operationsContinuity' provenance/omp-host-migration.json)"`,
+        '[[ "$sha" =~ ^[0-9a-f]{40}$ ]]',
+        `echo "repository=lyc-aon/oh-my-pi" >> "$GITHUB_OUTPUT"`,
+        `echo "sha=$sha" >> "$GITHUB_OUTPUT"`,
+      ];
+      for (const command of authorityCommands) {
+        if (!authorityStep?.run?.includes(command))
+          errors.push(`.github/workflows/ci.yml authority step is missing ${JSON.stringify(command)}`);
+      }
+      if (checkoutStep?.with?.repository !== "${{ steps.authority.outputs.repository }}")
+        errors.push(".github/workflows/ci.yml continuity checkout must use the validated repository output");
+      if (checkoutStep?.with?.ref !== "${{ steps.authority.outputs.sha }}")
+        errors.push(".github/workflows/ci.yml continuity checkout must use the validated SHA output");
+      if (checkoutStep?.with?.path !== ".continuity/omp")
+        errors.push(".github/workflows/ci.yml continuity checkout must use .continuity/omp");
+      if (continuityStep?.env?.T4_OMP_SOURCE_DIR !== "${{ github.workspace }}/.continuity/omp")
+        errors.push(".github/workflows/ci.yml continuity gate must target the checked-out OMP source");
+      if (continuityStep?.run !== "pnpm test:legacy-bridge-continuity")
+        errors.push(".github/workflows/ci.yml continuity gate must run the release-bound command");
+      if (
+        uploadStep?.if !== "${{ always() }}" ||
+        uploadStep?.with?.path !== "artifacts/legacy-bridge-continuity/" ||
+        uploadStep?.with?.["if-no-files-found"] !== "error"
+      )
+        errors.push(".github/workflows/ci.yml continuity evidence upload is not fail-closed");
+    }
+  } catch (error) {
+    errors.push(`.github/workflows/ci.yml is invalid YAML: ${error instanceof Error ? error.message : error}`);
+  }
+
   for (const expected of [
     "core:",
+    "legacy-bridge-continuity:",
+    'ref: ${{ github.event.pull_request.head.sha || github.sha }}',
+    `source_repository="$(jq -er '.sourceRepository' provenance/omp-host-migration.json)"`,
+    `test "$source_repository" = "https://github.com/lyc-aon/oh-my-pi"`,
+    `sha="$(jq -er '.inputs.operationsContinuity' provenance/omp-host-migration.json)"`,
+    '[[ "$sha" =~ ^[0-9a-f]{40}$ ]]',
+    `echo "repository=lyc-aon/oh-my-pi" >> "$GITHUB_OUTPUT"`,
+    "repository: ${{ steps.authority.outputs.repository }}",
+    "ref: ${{ steps.authority.outputs.sha }}",
+    "T4_OMP_SOURCE_DIR: ${{ github.workspace }}/.continuity/omp",
+    "run: pnpm test:legacy-bridge-continuity",
+    "path: artifacts/legacy-bridge-continuity/",
+    "if-no-files-found: error",
     "tooling:",
     "android-debug:",
     "name: verify",
     "if: ${{ always() }}",
-    "needs: [core, tooling, android-debug]",
+    "needs: [core, legacy-bridge-continuity, tooling, android-debug]",
     'test "$CORE_RESULT" = success',
+    'test "$CONTINUITY_RESULT" = success',
     'test "$TOOLING_RESULT" = success',
     'test "$ANDROID_RESULT" = success',
     "github.event_name == 'pull_request' && github.ref || github.sha",
diff --git a/scripts/check-release-consistency.test.mjs b/scripts/check-release-consistency.test.mjs
index 4d53645..4d9915f 100644
--- a/scripts/check-release-consistency.test.mjs
+++ b/scripts/check-release-consistency.test.mjs
@@ -242,7 +242,36 @@ test("rejects updater channel, stable manifest, and publication-contract drift",
     ],
     [
       ".github/workflows/ci.yml",
-      (text) => text.replace("needs: [core, tooling, android-debug]", "needs: [core, tooling]"),
+      (text) =>
+        text.replace(
+          "needs: [core, legacy-bridge-continuity, tooling, android-debug]",
+          "needs: [core, tooling, android-debug]",
+        ),
+    ],
+    [
+      ".github/workflows/ci.yml",
+      (text) =>
+        text.replace(
+          "ref: ${{ github.event.pull_request.head.sha || github.sha }}",
+          "ref: ${{ github.ref }}",
+        ),
+    ],
+    [
+      ".github/workflows/ci.yml",
+      (text) =>
+        replaceRequired(
+          text,
+          'test "$source_repository" = "https://github.com/lyc-aon/oh-my-pi"',
+          'test "$source_repository" = "https://github.com/example/other"',
+        ),
+    ],
+    [
+      ".github/workflows/ci.yml",
+      (text) => replaceRequired(text, '[[ "$sha" =~ ^[0-9a-f]{40}$ ]]', '[[ -n "$sha" ]]'),
+    ],
+    [
+      ".github/workflows/ci.yml",
+      (text) => text.replace("run: pnpm test:legacy-bridge-continuity", "run: pnpm test"),
     ],
     [
       "scripts/reconcile-release-assets.mjs",
@@ -474,11 +503,33 @@ test("deploys release site source only after artifact publication", () => {
 
   assert.ok(ciWorkflow.includes("android-debug:"));
   assert.ok(ciWorkflow.includes("core:"));
+  assert.ok(ciWorkflow.includes("legacy-bridge-continuity:"));
+  assert.ok(ciWorkflow.includes("ref: ${{ github.event.pull_request.head.sha || github.sha }}"));
+  assert.ok(
+    ciWorkflow.includes(
+      `source_repository="$(jq -er '.sourceRepository' provenance/omp-host-migration.json)"`,
+    ),
+  );
+  assert.ok(
+    ciWorkflow.includes('test "$source_repository" = "https://github.com/lyc-aon/oh-my-pi"'),
+  );
+  assert.ok(
+    ciWorkflow.includes("sha=\"$(jq -er '.inputs.operationsContinuity' provenance/omp-host-migration.json)\""),
+  );
+  assert.ok(ciWorkflow.includes('[[ "$sha" =~ ^[0-9a-f]{40}$ ]]'));
+  assert.ok(ciWorkflow.includes('echo "repository=lyc-aon/oh-my-pi" >> "$GITHUB_OUTPUT"'));
+  assert.ok(ciWorkflow.includes("repository: ${{ steps.authority.outputs.repository }}"));
+  assert.ok(ciWorkflow.includes("ref: ${{ steps.authority.outputs.sha }}"));
+  assert.ok(ciWorkflow.includes("T4_OMP_SOURCE_DIR: ${{ github.workspace }}/.continuity/omp"));
+  assert.ok(ciWorkflow.includes("run: pnpm test:legacy-bridge-continuity"));
+  assert.ok(ciWorkflow.includes("path: artifacts/legacy-bridge-continuity/"));
+  assert.ok(ciWorkflow.includes("if-no-files-found: error"));
   assert.ok(ciWorkflow.includes("tooling:"));
   assert.ok(ciWorkflow.includes("name: verify"));
   assert.ok(ciWorkflow.includes("if: ${{ always() }}"));
-  assert.ok(ciWorkflow.includes("needs: [core, tooling, android-debug]"));
+  assert.ok(ciWorkflow.includes("needs: [core, legacy-bridge-continuity, tooling, android-debug]"));
   assert.ok(ciWorkflow.includes('test "$CORE_RESULT" = success'));
+  assert.ok(ciWorkflow.includes('test "$CONTINUITY_RESULT" = success'));
   assert.ok(ciWorkflow.includes('test "$TOOLING_RESULT" = success'));
   assert.ok(ciWorkflow.includes('test "$ANDROID_RESULT" = success'));
   assert.ok(ciWorkflow.includes("github.event_name == 'pull_request' && github.ref || github.sha"));
diff --git a/scripts/operations-continuity-real.mjs b/scripts/legacy-bridge-continuity.mjs
similarity index 99%
rename from scripts/operations-continuity-real.mjs
rename to scripts/legacy-bridge-continuity.mjs
index b3b8564..602b7f7 100755
--- a/scripts/operations-continuity-real.mjs
+++ b/scripts/legacy-bridge-continuity.mjs
@@ -33,7 +33,7 @@ const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
 function parseArgs(argv) {
   const output = {
-    artifactRoot: resolve(repoRoot, "artifacts/operations-continuity"),
+    artifactRoot: resolve(repoRoot, "artifacts/legacy-bridge-continuity"),
     ompRepo: process.env.T4_OMP_SOURCE_DIR,
   };
   for (let index = 0; index < argv.length; index += 1) {
@@ -78,7 +78,7 @@ function delay(ms) {
 }
 
 function progress(stage) {
-  process.stderr.write(`[operations-continuity] ${stage}\n`);
+  process.stderr.write(`[legacy-bridge-continuity] ${stage}\n`);
 }
 
 async function waitUntil(check, label, timeoutMs = PROCESS_TIMEOUT_MS) {
@@ -470,7 +470,7 @@ class T4Probe {
       client: {
         name: "T4 Code",
         version: "0.1.28",
-        build: "operations-continuity",
+        build: "legacy-bridge-continuity",
         platform: process.platform,
       },
       reconnect: { baseMs: 100, maxMs: 1_000 },
@@ -646,14 +646,14 @@ function failureDescriptor(error) {
   };
 }
 
-export async function runOperationsContinuity(argv = []) {
+export async function runLegacyBridgeContinuity(argv = []) {
   const options = parseArgs(argv);
   const ompRepo = await realpath(options.ompRepo);
   const artifactRoot = options.artifactRoot;
   const runStamp = new Date().toISOString().replaceAll(":", "-").replaceAll(".", "-");
   const artifactDir = join(artifactRoot, runStamp);
   const temporaryBase = process.platform === "darwin" ? "/private/tmp" : tmpdir();
-  const temporaryRoot = await realpath(await mkdtemp(join(temporaryBase, "t4-ops-")));
+  const temporaryRoot = await realpath(await mkdtemp(join(temporaryBase, "t4-legacy-bridge-")));
   const home = join(temporaryRoot, "home");
   const projectsRoot = join(temporaryRoot, "projects");
   const projectA = join(projectsRoot, "project-a");
@@ -1191,6 +1191,8 @@ export async function runOperationsContinuity(argv = []) {
       v: 1,
       status: "passed",
       scenario: {
+        hostImplementation: "legacy-omp-appserver",
+        authorityImplementation: "lycaon-omp",
         profiles: 2,
         projects: 2,
         seededSessions: 27,
diff --git a/scripts/legacy-bridge-continuity.test.ts b/scripts/legacy-bridge-continuity.test.ts
new file mode 100644
index 0000000..ead2739
--- /dev/null
+++ b/scripts/legacy-bridge-continuity.test.ts
@@ -0,0 +1,12 @@
+import { test } from "vitest";
+import { runLegacyBridgeContinuity } from "./legacy-bridge-continuity.mjs";
+
+test(
+  "preserves T4 client continuity against the pinned legacy OMP appserver",
+  async () => {
+    const ompRepo = process.env.T4_OMP_SOURCE_DIR;
+    if (!ompRepo) throw new Error("set T4_OMP_SOURCE_DIR to the Lycaon OMP source worktree");
+    await runLegacyBridgeContinuity(["--omp-repo", ompRepo]);
+  },
+  600_000,
+);
diff --git a/scripts/operations-continuity-real.test.ts b/scripts/operations-continuity-real.test.ts
deleted file mode 100644
index d3e9292..0000000
--- a/scripts/operations-continuity-real.test.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { test } from "vitest";
-import { runOperationsContinuity } from "./operations-continuity-real.mjs";
-
-test(
-  "preserves OMP and T4 session continuity through ownership, reconnect, restart, and cleanup",
-  async () => {
-    const ompRepo = process.env.T4_OMP_SOURCE_DIR;
-    if (!ompRepo) throw new Error("set T4_OMP_SOURCE_DIR to the Lycaon OMP source worktree");
-    await runOperationsContinuity(["--omp-repo", ompRepo]);
-  },
-  600_000,
-);