diff --git a/apps/launcher/src/codex-runtime.ts b/apps/launcher/src/codex-runtime.ts
index ac98f36..beb3539 100644
--- a/apps/launcher/src/codex-runtime.ts
+++ b/apps/launcher/src/codex-runtime.ts
@@ -30,9 +30,12 @@ export interface CodexRuntime extends StandaloneRuntime {
 export async function startCodexRuntime(
   options: CodexRuntimeOptions,
 ): Promise<CodexRuntime> {
-  const standalone = await startStandaloneRuntime(options);
   let instance: DedicatedCodexInstance | null = null;
   let connection: HostConnection | null = null;
+  const standalone = await startStandaloneRuntime({
+    ...options,
+    nativeHostConnection: () => connection,
+  });
   let host: 'codex' | 'standalone' = 'standalone';
   let closing = false;
   let monitor = Promise.resolve();
diff --git a/apps/launcher/src/repository-protocol-adapter.ts b/apps/launcher/src/repository-protocol-adapter.ts
index 2c1d86b..e94a89b 100644
--- a/apps/launcher/src/repository-protocol-adapter.ts
+++ b/apps/launcher/src/repository-protocol-adapter.ts
@@ -1,4 +1,4 @@
-import { basename } from 'node:path';
+import { basename, isAbsolute } from 'node:path';
 
 import type {
   RepositoryOpenResult,
@@ -10,9 +10,24 @@ import {
   type RepositorySnapshotResult,
 } from '@codex-git/protocol';
 
+export interface HostNavigationContext {
+  readonly canonicalProjectPath: string | null;
+  readonly openCodexContext: boolean;
+  readonly openFileInCodex: boolean;
+  readonly taskId: string | null;
+}
+
+const noHostNavigation: HostNavigationContext = {
+  canonicalProjectPath: null,
+  openCodexContext: false,
+  openFileInCodex: false,
+  taskId: null,
+};
+
 export function toProtocolRepositorySnapshot(
   result: RepositoryOpenResult,
   projectPath: string,
+  hostNavigation: HostNavigationContext = noHostNavigation,
 ): RepositorySnapshotResult {
   if (result.kind === 'not_repository') {
     return {
@@ -56,6 +71,7 @@ export function toProtocolRepositorySnapshot(
         candidate.upstream.kind === 'tracking'
           ? (remoteFetches.get(candidate.upstream.remoteId) ?? null)
           : lastSuccessfulFetchAt(source.fetch),
+        hostNavigation,
       ),
     ),
     remotes: source.remotes.map(({ remoteId, displayName, host }) => ({
@@ -72,7 +88,11 @@ export function toProtocolRepositorySnapshot(
   });
 }
 
-function worktree(source: PublishedWorktreeSnapshot, fetchedAt: string | null) {
+function worktree(
+  source: PublishedWorktreeSnapshot,
+  fetchedAt: string | null,
+  hostNavigation: HostNavigationContext,
+) {
   const path = source.canonicalPath ?? source.displayPath;
   return {
     worktreeId: source.worktreeId,
@@ -101,6 +121,14 @@ function worktree(source: PublishedWorktreeSnapshot, fetchedAt: string | null) {
             },
     indexTree: null,
     status: worktreeStatus(source),
+    provenance:
+      source.provenance.kind === 'codex_task'
+        ? {
+            kind: source.provenance.kind,
+            title: source.provenance.task.title,
+            status: source.provenance.task.status,
+          }
+        : source.provenance,
     upstream: upstream(source, fetchedAt),
     changes: source.changes.map(
       ({
@@ -116,15 +144,20 @@ function worktree(source: PublishedWorktreeSnapshot, fetchedAt: string | null) {
         baseline,
         displayPath,
         previousDisplayPath,
-        nativeTargets: [nativeFileTarget(source, nativeTargetId, fileId)],
+        nativeTargets: [
+          nativeFileTarget(source, nativeTargetId, fileId, hostNavigation),
+        ],
       }),
     ),
-    nativeTargets: [
-      {
-        targetId: source.nativeTargetId,
-        actions: ['open_terminal'] as const,
-      },
-    ],
+    nativeTargets:
+      source.nativeTargetId === null
+        ? []
+        : [
+            {
+              targetId: source.nativeTargetId,
+              actions: worktreeNativeActions(source, hostNavigation),
+            },
+          ],
   };
 }
 
@@ -132,6 +165,7 @@ function nativeFileTarget(
   worktree: PublishedWorktreeSnapshot,
   targetId: PublishedWorktreeSnapshot['changes'][number]['nativeTargetId'],
   fileId: PublishedWorktreeSnapshot['changes'][number]['fileId'],
+  hostNavigation: HostNavigationContext,
 ) {
   const change = worktree.changes.find(
     (candidate) => candidate.fileId === fileId,
@@ -144,13 +178,78 @@ function nativeFileTarget(
   }
   return {
     targetId,
-    actions:
-      change.workingFilePresent && pathIsUtf8
-        ? (['open_default_app', 'copy_relative_path'] as const)
-        : (['copy_relative_path'] as const),
+    actions: fileNativeActions(
+      worktree,
+      pathIsUtf8,
+      change.workingFilePresent,
+      hostNavigation,
+    ),
   };
 }
 
+function worktreeNativeActions(
+  worktree: PublishedWorktreeSnapshot,
+  hostNavigation: HostNavigationContext,
+) {
+  const path = worktree.canonicalPath ?? worktree.displayPath;
+  const copyActions = [
+    ...(isAbsolute(path) ? (['copy_absolute_path'] as const) : []),
+    'copy_branch_or_sha' as const,
+  ];
+  const hostActions =
+    hostNavigation.openCodexContext &&
+    hostContextMatches(worktree, hostNavigation)
+      ? (['open_codex_context'] as const)
+      : [];
+  return worktree.canonicalPath !== null &&
+    worktree.availability.kind === 'available'
+    ? ([
+        'open_terminal',
+        'reveal_in_finder',
+        ...hostActions,
+        ...copyActions,
+      ] as const)
+    : [...hostActions, ...copyActions];
+}
+
+function fileNativeActions(
+  worktree: PublishedWorktreeSnapshot,
+  pathIsUtf8: boolean,
+  workingFilePresent: boolean,
+  hostNavigation: HostNavigationContext,
+) {
+  if (!pathIsUtf8) return ['copy_relative_path'] as const;
+  const copyActions = [
+    'copy_relative_path' as const,
+    ...(worktree.canonicalPath === null
+      ? []
+      : (['copy_absolute_path'] as const)),
+  ];
+  return workingFilePresent && worktree.canonicalPath !== null
+    ? ([
+        'open_default_app',
+        'reveal_in_finder',
+        ...(hostNavigation.openFileInCodex &&
+        hostContextMatches(worktree, hostNavigation)
+          ? (['open_file_in_codex'] as const)
+          : []),
+        ...copyActions,
+      ] as const)
+    : copyActions;
+}
+
+function hostContextMatches(
+  worktree: PublishedWorktreeSnapshot,
+  hostNavigation: HostNavigationContext,
+): boolean {
+  return (
+    (worktree.provenance.kind === 'codex_task' &&
+      worktree.provenance.task.id === hostNavigation.taskId) ||
+    (worktree.canonicalPath !== null &&
+      worktree.canonicalPath === hostNavigation.canonicalProjectPath)
+  );
+}
+
 function refresh(source: RefreshState) {
   if (source.kind === 'fresh') return { kind: 'current' as const };
   return { kind: source.kind, message: source.error.message } as const;
diff --git a/apps/launcher/src/standalone-runtime.ts b/apps/launcher/src/standalone-runtime.ts
index 12273d2..ae53d3e 100644
--- a/apps/launcher/src/standalone-runtime.ts
+++ b/apps/launcher/src/standalone-runtime.ts
@@ -8,6 +8,7 @@ import { promisify } from 'node:util';
 import type { HostConnection } from '@codex-git/host-adapter';
 import {
   createRepositoryEngine,
+  type CodexMetadataAdapter,
   type RepositorySession,
 } from '@codex-git/repository-engine';
 import type {
@@ -32,6 +33,8 @@ const uiConfigPath = fileURLToPath(
 );
 
 export interface StandaloneRuntimeOptions {
+  readonly metadata?: CodexMetadataAdapter;
+  readonly nativeHostConnection?: () => HostConnection | null;
   readonly projectPath?: string;
   readonly surfacePort?: number;
 }
@@ -65,9 +68,9 @@ export async function startStandaloneRuntime(
 
   try {
     if (options.projectPath !== undefined) {
-      repositorySession = await createRepositoryEngine().open(
-        options.projectPath as AbsolutePath,
-      );
+      repositorySession = await createRepositoryEngine({
+        metadata: options.metadata,
+      }).open(options.projectPath as AbsolutePath);
       const opened = await repositorySession.requestRefresh();
       if (opened.kind === 'repository') {
         openedRepositoryId = opened.repository.repositoryId;
@@ -81,14 +84,23 @@ export async function startStandaloneRuntime(
           : {
               diff: ({ fileId }) => repositorySession!.diff(fileId),
               nativeActions: (request) =>
-                performNativeAction(repositorySession!, request),
+                performNativeAction(
+                  repositorySession!,
+                  request,
+                  options.nativeHostConnection,
+                ),
               branchSearch: (request) =>
                 repositorySession!.searchBranches(request),
-              snapshot: async () =>
-                toProtocolRepositorySnapshot(
-                  await repositorySession!.requestRefresh(),
+              snapshot: async () => {
+                const result = await repositorySession!.requestRefresh();
+                return toProtocolRepositorySnapshot(
+                  result,
                   options.projectPath!,
-                ),
+                  await hostNavigationContext(
+                    options.nativeHostConnection?.() ?? null,
+                  ),
+                );
+              },
               commands: (request) =>
                 dispatchRepositoryCommand(repositorySession!, request),
               operationRecovery: (operationId) =>
@@ -192,17 +204,14 @@ async function dispatchRepositoryCommand(
 async function performNativeAction(
   session: RepositorySession,
   request: NativeActionRequest,
+  nativeHostConnection?: () => HostConnection | null,
 ): Promise<NativeActionResult> {
   if (request.kind === 'open_terminal') {
     try {
       const target = await session.resolveWorktreeNativeTarget(
         request.targetId,
       );
-      const metadata = await lstat(target.worktreePath);
-      if (metadata.isSymbolicLink() || !metadata.isDirectory()) {
-        throw new Error('The Worktree target is not a directory.');
-      }
-      const resolvedWorktree = await realpath(target.worktreePath);
+      const resolvedWorktree = await revalidateWorktreePath(target);
       await execFileAsync(
         '/usr/bin/open',
         ['-a', 'Terminal', '--', resolvedWorktree],
@@ -220,21 +229,72 @@ async function performNativeAction(
     }
   }
   try {
-    const target = await session.resolveFileNativeTarget(request.targetId);
     if (request.kind === 'copy_relative_path') {
+      const target = await session.resolveFileNativeTarget(request.targetId);
       return { kind: 'copy_text', text: target.relativePath };
     }
-    if (request.kind !== 'open_default_app') {
-      return {
-        kind: 'unavailable',
-        message: 'This file action is not available yet.',
-      };
+    if (request.kind === 'copy_branch_or_sha') {
+      const target = await session.resolveWorktreeNativeTarget(
+        request.targetId,
+      );
+      return { kind: 'copy_text', text: target.branchOrSha };
     }
-    if (!target.canOpen || target.absolutePath === null) {
-      throw new Error('The file cannot be opened from this change state.');
+    if (request.kind === 'copy_absolute_path') {
+      const target = await resolvePathTarget(session, request.targetId);
+      if (target.kind === 'worktree') {
+        await revalidateWorktreePath(target);
+      }
+      return { kind: 'copy_text', text: target.absolutePath };
+    }
+    if (
+      request.kind === 'open_codex_context' ||
+      request.kind === 'open_file_in_codex'
+    ) {
+      const host = nativeHostConnection?.() ?? null;
+      if (host === null) throw new Error('The Codex host is unavailable.');
+      const capabilities = host.capabilities();
+      const target =
+        request.kind === 'open_codex_context'
+          ? await session.resolveWorktreeNativeTarget(request.targetId)
+          : await session.resolveFileNativeTarget(request.targetId);
+      if (
+        (request.kind === 'open_codex_context'
+          ? !capabilities.openCodexContext
+          : !capabilities.openFileInCodex) ||
+        !(await hostContextMatches(
+          host,
+          target.worktreePath,
+          target.provenance,
+        ))
+      ) {
+        throw new Error('The Codex host cannot prove the exact target.');
+      }
+      const hostResult = await host.perform({
+        kind:
+          request.kind === 'open_codex_context'
+            ? 'open-codex-context'
+            : 'open-file-in-codex',
+        targetId: request.targetId,
+      });
+      if (hostResult.status !== 'succeeded') {
+        throw new Error('The Codex host rejected the exact target.');
+      }
+      return { kind: 'performed' };
+    }
+    const target = await resolvePathTarget(session, request.targetId);
+    if (!target.canLaunch) {
+      throw new Error('The target cannot be opened from its current state.');
+    }
+    if (target.kind === 'worktree') {
+      const path = await revalidateWorktreePath(target);
+      await execFileAsync('/usr/bin/open', ['-R', '--', path], {
+        timeout: 10_000,
+        windowsHide: true,
+      });
+      return { kind: 'performed' };
     }
     const metadata = await lstat(target.absolutePath);
-    if (metadata.isSymbolicLink()) {
+    if (request.kind === 'open_default_app' && metadata.isSymbolicLink()) {
       throw new Error('Symbolic links cannot be opened from change review.');
     }
     const [resolvedWorktree, resolvedFile] = await Promise.all([
@@ -252,17 +312,117 @@ async function performNativeAction(
     ) {
       throw new Error('The file resolves outside its Worktree.');
     }
-    await execFileAsync('/usr/bin/open', ['--', resolvedFile], {
-      timeout: 10_000,
-      windowsHide: true,
-    });
+    await execFileAsync(
+      '/usr/bin/open',
+      request.kind === 'reveal_in_finder'
+        ? ['-R', '--', target.absolutePath]
+        : ['--', resolvedFile],
+      {
+        timeout: 10_000,
+        windowsHide: true,
+      },
+    );
     return { kind: 'performed' };
   } catch {
     return {
       kind: 'unavailable',
-      message: 'The file is no longer available. Refresh and try again.',
+      message:
+        'The exact target is no longer available. Refresh or use a safe copy action.',
+    };
+  }
+}
+
+async function hostNavigationContext(host: HostConnection | null) {
+  if (host === null) {
+    return {
+      canonicalProjectPath: null,
+      openCodexContext: false,
+      openFileInCodex: false,
+      taskId: null,
+    } as const;
+  }
+  const context = host.currentContext();
+  return {
+    ...host.capabilities(),
+    canonicalProjectPath:
+      context.projectPath === null
+        ? null
+        : await realpath(context.projectPath).catch(() => null),
+    taskId: context.task?.id ?? null,
+  };
+}
+
+async function hostContextMatches(
+  host: HostConnection,
+  worktreePath: string,
+  provenance: import('@codex-git/repository-engine').WorktreeProvenance,
+): Promise<boolean> {
+  const before = host.currentContext();
+  const canonicalProjectPath =
+    before.projectPath === null
+      ? null
+      : await realpath(before.projectPath).catch(() => null);
+  const current = host.currentContext();
+  if (
+    current.projectPath !== before.projectPath ||
+    current.task?.id !== before.task?.id
+  ) {
+    return false;
+  }
+  return (
+    (provenance.kind === 'codex_task' &&
+      provenance.task.id === current.task?.id) ||
+    canonicalProjectPath === worktreePath
+  );
+}
+
+type ResolvedPathTarget =
+  | {
+      readonly kind: 'file';
+      readonly absolutePath: string;
+      readonly canLaunch: boolean;
+      readonly worktreePath: string;
+    }
+  | {
+      readonly kind: 'worktree';
+      readonly absolutePath: string;
+      readonly canLaunch: boolean;
+      readonly worktreePath: string;
+    };
+
+async function resolvePathTarget(
+  session: RepositorySession,
+  targetId: NativeActionRequest['targetId'],
+): Promise<ResolvedPathTarget> {
+  try {
+    const file = await session.resolveFileNativeTarget(targetId);
+    if (file.absolutePath === null) throw new Error('No file path.');
+    return {
+      kind: 'file',
+      absolutePath: file.absolutePath,
+      canLaunch: file.canOpen,
+      worktreePath: file.worktreePath,
     };
+  } catch {
+    const worktree = await session.resolveWorktreeNativeTarget(targetId);
+    return {
+      kind: 'worktree',
+      absolutePath: worktree.absolutePath,
+      canLaunch: worktree.canLaunch,
+      worktreePath: worktree.worktreePath,
+    };
+  }
+}
+
+async function revalidateWorktreePath(
+  target: Pick<ResolvedPathTarget, 'canLaunch' | 'worktreePath'>,
+): Promise<string> {
+  if (!target.canLaunch) throw new Error('The Worktree is unavailable.');
+  const resolved = await realpath(target.worktreePath);
+  if (resolved !== target.worktreePath) {
+    throw new Error('The Worktree moved before navigation.');
   }
+  return resolved;
 }
 
 async function forwardRepositoryInvalidations(
diff --git a/apps/server/src/protocol-dispatch.test.ts b/apps/server/src/protocol-dispatch.test.ts
index a5c3b31..2119427 100644
--- a/apps/server/src/protocol-dispatch.test.ts
+++ b/apps/server/src/protocol-dispatch.test.ts
@@ -65,6 +65,7 @@ describe('protocol HTTP dispatch', () => {
             kind: 'unavailable',
             reason: 'token=fixture-unavailable-secret',
           },
+          provenance: { kind: 'unclassified' },
           upstream: {
             kind: 'not-applicable',
             reason: 'The branch has no configured Upstream.',
@@ -839,6 +840,7 @@ function nativeSnapshot(
         head: { kind: 'initial' },
         indexTree: null,
         status: { kind: 'clean' },
+        provenance: { kind: 'unclassified' },
         upstream: {
           kind: 'not-applicable',
           reason: 'The branch has no configured Upstream.',
diff --git a/apps/ui/src/DiffReview.tsx b/apps/ui/src/DiffReview.tsx
index b636110..c837362 100644
--- a/apps/ui/src/DiffReview.tsx
+++ b/apps/ui/src/DiffReview.tsx
@@ -9,6 +9,10 @@ import type {
 import type { WorktreeOverviewSnapshot } from './repository-overview-model.js';
 import type { DiffLoadState } from './repository-store.js';
 import { presentSideBySide } from './diff-presentation.js';
+import {
+  nativeActionLabel,
+  performPresentedNativeAction,
+} from './native-action-presentation.js';
 
 export function DiffReview({
   worktree,
@@ -96,15 +100,15 @@ export function DiffReview({
           target.actions
             .filter(
               (kind) =>
-                kind === 'open_default_app' || kind === 'copy_relative_path',
+                kind === 'open_default_app' ||
+                kind === 'open_file_in_codex' ||
+                kind === 'reveal_in_finder' ||
+                kind === 'copy_relative_path' ||
+                kind === 'copy_absolute_path',
             )
             .map((kind) => (
               <button
-                aria-label={
-                  kind === 'open_default_app'
-                    ? 'Open in Default App'
-                    : 'Copy Relative Path'
-                }
+                aria-label={nativeActionLabel(kind)}
                 key={`${target.targetId}:${kind}`}
                 type="button"
                 onClick={() =>
@@ -116,9 +120,7 @@ export function DiffReview({
                   )
                 }
               >
-                {kind === 'open_default_app'
-                  ? 'Open in Default App'
-                  : 'Copy Relative Path'}
+                {nativeActionLabel(kind)}
               </button>
             )),
         )}
@@ -135,25 +137,23 @@ async function performNativeAction(
   run: (request: NativeActionRequest) => Promise<NativeActionResult>,
   publish: (message: string) => void,
 ): Promise<void> {
-  try {
-    const result = await run(request);
-    if (result.kind === 'unavailable') {
-      publish(result.message);
-      return;
-    }
-    if (result.kind === 'performed') {
-      publish('Opened the current Changed File.');
-      return;
-    }
-    if (globalThis.navigator.clipboard === undefined) {
-      publish(`Relative path: ${result.text}`);
-      return;
-    }
-    await globalThis.navigator.clipboard.writeText(result.text);
-    publish('Copied the relative path.');
-  } catch {
-    publish('The file action could not be completed. Refresh and try again.');
-  }
+  return performPresentedNativeAction(request, run, publish, {
+    performed: (current) =>
+      current.kind === 'reveal_in_finder'
+        ? 'Revealed the current Changed File.'
+        : current.kind === 'open_file_in_codex'
+          ? 'Opened the current Changed File in Codex.'
+          : 'Opened the current Changed File.',
+    copyFallback: (current, text) =>
+      current.kind === 'copy_absolute_path'
+        ? `Absolute path: ${text}`
+        : `Relative path: ${text}`,
+    copied: (current) =>
+      current.kind === 'copy_absolute_path'
+        ? 'Copied the absolute path.'
+        : 'Copied the relative path.',
+    failed: 'The file action could not be completed. Refresh and try again.',
+  });
 }
 
 function DiffContent({
diff --git a/apps/ui/src/RepositoryOverview.interactions.test.tsx b/apps/ui/src/RepositoryOverview.interactions.test.tsx
index 89ca75a..936ba3e 100644
--- a/apps/ui/src/RepositoryOverview.interactions.test.tsx
+++ b/apps/ui/src/RepositoryOverview.interactions.test.tsx
@@ -209,10 +209,42 @@ describe('Repository overview interactions', () => {
     expect(container.textContent).toContain('Binary file · 4,096 bytes');
     expect(container.querySelector('pre')).toBeNull();
     expect(button('Open in Default App')).toBeDefined();
+    expect(button('Reveal in Finder')).toBeDefined();
+    expect(button('Copy Absolute Path')).toBeDefined();
     await act(async () => button('Copy Relative Path').click());
     expect(container.textContent).toContain('Relative path: README.md');
   });
 
+  it('reports exact Worktree copy results and safe navigation fallback', async () => {
+    const fixture = createOverviewFixture('one-worktree');
+    const store = createRepositoryStore({
+      ...fixture.source,
+      async requestNativeAction(request) {
+        return request.kind === 'copy_absolute_path'
+          ? {
+              kind: 'copy_text',
+              text: '/Users/leyoonafr/Projects/codex-git',
+            }
+          : {
+              kind: 'unavailable',
+              message:
+                'The exact target is no longer available. Refresh or use a safe copy action.',
+            };
+      },
+    });
+    act(() => root.render(<App store={store} />));
+
+    await act(async () => button('Copy Absolute Path for codex-git').click());
+    expect(container.textContent).toContain(
+      'Value: /Users/leyoonafr/Projects/codex-git',
+    );
+
+    await act(async () => button('Reveal codex-git in Finder').click());
+    expect(container.textContent).toContain(
+      'The exact target is no longer available. Refresh or use a safe copy action.',
+    );
+  });
+
   it('shows Conflict index stages in the default side-by-side review', async () => {
     const fixture = createOverviewFixture('changed-worktree');
     const store = createRepositoryStore({
diff --git a/apps/ui/src/RepositoryOverview.test.tsx b/apps/ui/src/RepositoryOverview.test.tsx
index 5790165..942f950 100644
--- a/apps/ui/src/RepositoryOverview.test.tsx
+++ b/apps/ui/src/RepositoryOverview.test.tsx
@@ -21,11 +21,49 @@ describe('Repository overview', () => {
     expect(markup).toContain('<dt>Upstream freshness</dt>');
     expect(markup).toContain('Cached from Fetch Aug 29, 2026, 2:03 PM');
     expect(markup).toContain('Clean');
+    expect(markup).toContain(
+      '<dt>Provenance</dt><dd>Unclassified Worktree</dd>',
+    );
+    expect(markup).toContain('Open codex-git in Terminal');
+    expect(markup).toContain('Reveal codex-git in Finder');
+    expect(markup).toContain('Copy Absolute Path for codex-git');
+    expect(markup).toContain('Copy Branch or SHA for codex-git');
     expect(markup).toContain('Refresh codex-git locally');
     expect(markup).toContain('Fetch origin for codex-git');
     expect(markup).not.toContain('Search Worktrees');
   });
 
+  it.each([
+    [
+      { kind: 'codex_task', title: 'Exact task', status: 'active' } as const,
+      'Codex Task Worktree — Exact task (active)',
+    ],
+    [{ kind: 'scheduled' } as const, 'Scheduled Worktree'],
+    [{ kind: 'permanent' } as const, 'Permanent Worktree'],
+    [{ kind: 'external' } as const, 'External Worktree'],
+    [{ kind: 'unclassified' } as const, 'Unclassified Worktree'],
+  ])('uses the canonical provenance term for %s', (provenance, label) => {
+    const fixture = createOverviewFixture('one-worktree');
+    const source = fixture.source.getSnapshot();
+    if (source.kind !== 'repository') throw new Error('Expected Repository');
+    fixture.publish({
+      kind: 'repository',
+      snapshot: {
+        ...source.snapshot,
+        worktrees: source.snapshot.worktrees.map((worktree) => ({
+          ...worktree,
+          provenance,
+        })),
+      },
+    });
+
+    const markup = renderToStaticMarkup(
+      <App store={createRepositoryStore(fixture.source)} />,
+    );
+
+    expect(markup).toContain(`<dt>Provenance</dt><dd>${label}</dd>`);
+  });
+
   it('keeps Main first and the remaining Worktrees stable when status changes', () => {
     const fixture = createOverviewFixture('many-worktrees');
     const store = createRepositoryStore(fixture.source);
diff --git a/apps/ui/src/RepositoryOverview.tsx b/apps/ui/src/RepositoryOverview.tsx
index 11a6f4a..c5d54b0 100644
--- a/apps/ui/src/RepositoryOverview.tsx
+++ b/apps/ui/src/RepositoryOverview.tsx
@@ -1,4 +1,9 @@
-import { useEffect, useRef, useSyncExternalStore } from 'react';
+import { useEffect, useRef, useState, useSyncExternalStore } from 'react';
+
+import type {
+  NativeActionRequest,
+  NativeActionResult,
+} from '@codex-git/protocol';
 
 import type {
   RepositoryOverviewSnapshot,
@@ -10,6 +15,11 @@ import type {
 } from './repository-store.js';
 import { ChangeGroups } from './ChangeGroups.js';
 import { DiffReview } from './DiffReview.js';
+import {
+  nativeActionLabel,
+  performPresentedNativeAction,
+  worktreeNativeActionLabel,
+} from './native-action-presentation.js';
 
 export function RepositoryOverview({
   store,
@@ -26,6 +36,10 @@ export function RepositoryOverview({
   const searchInput = useRef<HTMLInputElement>(null);
   const worktreeTitle = useRef<HTMLHeadingElement>(null);
   const handledFocusRecovery = useRef(0);
+  const [nativeActionStatus, setNativeActionStatus] = useState<{
+    readonly worktreeId: string;
+    readonly message: string;
+  } | null>(null);
   const orderedWorktrees =
     state.source.kind === 'repository'
       ? [...state.source.snapshot.worktrees].sort(compareWorktrees)
@@ -348,6 +362,10 @@ export function RepositoryOverview({
                 <dt>Status</dt>
                 <dd>{statusLabel(selected.status)}</dd>
               </div>
+              <div>
+                <dt>Provenance</dt>
+                <dd>{provenanceLabel(selected.provenance)}</dd>
+              </div>
               <div>
                 <dt>Worktree observation</dt>
                 <dd>{refreshLabel(selected.freshness)}</dd>
@@ -362,6 +380,31 @@ export function RepositoryOverview({
               )}
             </dl>
             <div>
+              {selected.nativeTargets.flatMap((target) =>
+                target.actions.map((kind) => (
+                  <button
+                    aria-label={worktreeNativeActionLabel(
+                      kind,
+                      selected.displayName,
+                    )}
+                    key={`${target.targetId}:${kind}`}
+                    type="button"
+                    onClick={() =>
+                      void performWorktreeNativeAction(
+                        { kind, targetId: target.targetId },
+                        store.requestNativeAction,
+                        (message) =>
+                          setNativeActionStatus({
+                            worktreeId: selected.worktreeId,
+                            message,
+                          }),
+                      )
+                    }
+                  >
+                    {nativeActionLabel(kind)}
+                  </button>
+                )),
+              )}
               <button
                 aria-label={`Switch Branch for ${selected.displayName}`}
                 type="button"
@@ -435,6 +478,11 @@ export function RepositoryOverview({
                 })
               ) : null}
             </div>
+            {nativeActionStatus?.worktreeId !== selected.worktreeId ? null : (
+              <p aria-live="polite" role="status">
+                {nativeActionStatus.message}
+              </p>
+            )}
             {selected.upstream.kind === 'tracking' &&
             (selected.upstream.ahead ?? 0) > 0 &&
             (selected.upstream.behind ?? 0) > 0 ? (
@@ -767,13 +815,43 @@ function matchesSearch(
     worktree.displayName,
     worktree.path,
     branch,
-    worktree.codexTitle ?? '',
+    worktree.provenance.kind === 'codex_task' ? worktree.provenance.title : '',
   ]
     .join('\n')
     .toLocaleLowerCase()
     .includes(normalizedQuery);
 }
 
+function provenanceLabel(
+  provenance: WorktreeOverviewSnapshot['provenance'],
+): string {
+  switch (provenance.kind) {
+    case 'codex_task':
+      return `Codex Task Worktree — ${provenance.title} (${provenance.status})`;
+    case 'scheduled':
+      return 'Scheduled Worktree';
+    case 'permanent':
+      return 'Permanent Worktree';
+    case 'external':
+      return 'External Worktree';
+    case 'unclassified':
+      return 'Unclassified Worktree';
+  }
+}
+
+async function performWorktreeNativeAction(
+  request: NativeActionRequest,
+  run: (request: NativeActionRequest) => Promise<NativeActionResult>,
+  publish: (message: string) => void,
+): Promise<void> {
+  return performPresentedNativeAction(request, run, publish, {
+    performed: () => 'Opened the exact Worktree target.',
+    copyFallback: (_current, text) => `Value: ${text}`,
+    copied: () => 'Copied the exact Worktree value.',
+    failed: 'The exact target is unavailable. Refresh and try again.',
+  });
+}
+
 function headLabel(head: WorktreeOverviewSnapshot['head']): string {
   if (head.kind === 'initial') return 'Initial Repository State';
   if (head.kind === 'detached')
diff --git a/apps/ui/src/native-action-presentation.ts b/apps/ui/src/native-action-presentation.ts
new file mode 100644
index 0000000..2411ad5
--- /dev/null
+++ b/apps/ui/src/native-action-presentation.ts
@@ -0,0 +1,68 @@
+import type {
+  NativeActionRequest,
+  NativeActionResult,
+} from '@codex-git/protocol';
+
+export function nativeActionLabel(kind: NativeActionRequest['kind']): string {
+  switch (kind) {
+    case 'open_terminal':
+      return 'Open in Terminal';
+    case 'reveal_in_finder':
+      return 'Reveal in Finder';
+    case 'copy_absolute_path':
+      return 'Copy Absolute Path';
+    case 'copy_branch_or_sha':
+      return 'Copy Branch or SHA';
+    case 'open_codex_context':
+      return 'Open Codex Context';
+    case 'open_file_in_codex':
+      return 'Open File in Codex';
+    case 'copy_relative_path':
+      return 'Copy Relative Path';
+    case 'open_default_app':
+      return 'Open in Default App';
+  }
+}
+
+export function worktreeNativeActionLabel(
+  kind: NativeActionRequest['kind'],
+  worktreeName: string,
+): string {
+  if (kind === 'open_terminal') return `Open ${worktreeName} in Terminal`;
+  if (kind === 'reveal_in_finder') return `Reveal ${worktreeName} in Finder`;
+  return `${nativeActionLabel(kind)} for ${worktreeName}`;
+}
+
+export interface NativeActionPresentation {
+  copied(request: NativeActionRequest): string;
+  copyFallback(request: NativeActionRequest, text: string): string;
+  failed: string;
+  performed(request: NativeActionRequest): string;
+}
+
+export async function performPresentedNativeAction(
+  request: NativeActionRequest,
+  run: (request: NativeActionRequest) => Promise<NativeActionResult>,
+  publish: (message: string) => void,
+  presentation: NativeActionPresentation,
+): Promise<void> {
+  try {
+    const result = await run(request);
+    if (result.kind === 'unavailable') {
+      publish(result.message);
+      return;
+    }
+    if (result.kind === 'performed') {
+      publish(presentation.performed(request));
+      return;
+    }
+    if (globalThis.navigator.clipboard === undefined) {
+      publish(presentation.copyFallback(request, result.text));
+      return;
+    }
+    await globalThis.navigator.clipboard.writeText(result.text);
+    publish(presentation.copied(request));
+  } catch {
+    publish(presentation.failed);
+  }
+}
diff --git a/apps/ui/src/overview-fixtures.ts b/apps/ui/src/overview-fixtures.ts
index 5f0e389..cc2f3b4 100644
--- a/apps/ui/src/overview-fixtures.ts
+++ b/apps/ui/src/overview-fixtures.ts
@@ -149,7 +149,7 @@ const changedFileIds = [1, 2, 3, 4].map((index) =>
 const changedNativeTargetIds = [1, 2, 3, 4].map((index) =>
   nativeTargetIdSchema.parse(`native_${index.toString(16).padStart(32, '0')}`),
 );
-const worktreeNativeTargetId = nativeTargetIdSchema.parse(
+const mainNativeTargetId = nativeTargetIdSchema.parse(
   'native_00000000000000000000000000000010',
 );
 
@@ -179,9 +179,18 @@ export const oneWorktree: RepositoryOverviewSnapshot = {
         objectId: '0123456789abcdef0123456789abcdef01234567',
       },
       status: { kind: 'clean' },
+      provenance: { kind: 'unclassified' },
       changes: [],
       nativeTargets: [
-        { targetId: worktreeNativeTargetId, actions: ['open_terminal'] },
+        {
+          targetId: mainNativeTargetId,
+          actions: [
+            'open_terminal',
+            'reveal_in_finder',
+            'copy_absolute_path',
+            'copy_branch_or_sha',
+          ],
+        },
       ],
       upstream: {
         kind: 'tracking',
@@ -249,7 +258,12 @@ export const changedWorktree: RepositoryOverviewSnapshot = {
 function nativeFileTarget(index: number) {
   return {
     targetId: changedNativeTargetIds[index]!,
-    actions: ['open_default_app', 'copy_relative_path'] as const,
+    actions: [
+      'open_default_app',
+      'reveal_in_finder',
+      'copy_relative_path',
+      'copy_absolute_path',
+    ] as const,
   };
 }
 
@@ -274,7 +288,14 @@ const linkedWorktrees: RepositoryOverviewSnapshot['worktrees'] = Array.from(
       role: 'linked' as const,
       displayName,
       path: `/private/tmp/codex-git-${displayName}`,
-      codexTitle: index === 2 ? 'Build the adaptive overview' : undefined,
+      provenance:
+        index === 2
+          ? {
+              kind: 'codex_task' as const,
+              title: 'Build the adaptive overview',
+              status: 'active',
+            }
+          : { kind: 'unclassified' as const },
       freshness: { kind: 'current' as const },
       head: {
         kind: 'local_branch' as const,
diff --git a/apps/ui/src/protocol-repository-source.test.ts b/apps/ui/src/protocol-repository-source.test.ts
index 83ce64a..647cd7b 100644
--- a/apps/ui/src/protocol-repository-source.test.ts
+++ b/apps/ui/src/protocol-repository-source.test.ts
@@ -521,6 +521,7 @@ const repositorySnapshot = {
       },
       indexTree: null,
       status: { kind: 'clean' },
+      provenance: { kind: 'unclassified' },
       upstream: { kind: 'unpublished', remoteName: null, fetchedAt: null },
       changes: [],
       nativeTargets: [],
diff --git a/apps/ui/src/repository-overview-model.ts b/apps/ui/src/repository-overview-model.ts
index 3bb4c5c..8c4a8d3 100644
--- a/apps/ui/src/repository-overview-model.ts
+++ b/apps/ui/src/repository-overview-model.ts
@@ -52,7 +52,7 @@ export interface WorktreeOverviewSnapshot {
   readonly displayName: string;
   readonly path: string;
   readonly availability?: ProtocolWorktree['availability'];
-  readonly codexTitle?: string;
+  readonly provenance: ProtocolWorktree['provenance'];
   readonly freshness: ProtocolWorktree['freshness'];
   readonly head: ProtocolWorktree['head'];
   readonly status: ProtocolWorktree['status'];
diff --git a/packages/host-adapter/codex-cdp/src/adapter.test.ts b/packages/host-adapter/codex-cdp/src/adapter.test.ts
index dbfa5e9..6994a3c 100644
--- a/packages/host-adapter/codex-cdp/src/adapter.test.ts
+++ b/packages/host-adapter/codex-cdp/src/adapter.test.ts
@@ -199,6 +199,42 @@ describe('CodexCdpHostAdapter', () => {
     await result.connection.close();
   });
 
+  it('restores the proven current Codex context but does not claim file navigation', async () => {
+    const dom = compatibleDom();
+    const result = await new CodexCdpHostAdapter({
+      rendererSource: new FixtureRendererSource(
+        fixtureRenderer(dom, '26.820.60940'),
+      ),
+    }).attach({
+      title: 'Codex Git',
+      url: new URL('http://127.0.0.1:4173'),
+    });
+    if (result.kind !== 'attached') {
+      throw new Error('Expected the compatible Codex renderer to attach');
+    }
+    documentEntry(dom)?.click();
+
+    expect(result.connection.capabilities()).toEqual({
+      openCodexContext: true,
+      openFileInCodex: false,
+    });
+    await expect(
+      result.connection.perform({
+        kind: 'open-codex-context',
+        targetId: 'native_0123456789abcdef0123456789abcdef',
+      }),
+    ).resolves.toEqual({ status: 'succeeded' });
+    expect(documentFrame(dom)).toBeNull();
+    await expect(
+      result.connection.perform({
+        kind: 'open-file-in-codex',
+        targetId: 'native_0123456789abcdef0123456789abcdef',
+      }),
+    ).resolves.toEqual({ status: 'unsupported' });
+
+    await result.connection.close();
+  });
+
   it('forwards Current Project, theme, and current task context changes', async () => {
     const dom = compatibleDom();
     const renderer = new FixtureRenderer(dom, '26.820.60940', {
diff --git a/packages/host-adapter/codex-cdp/src/connection.ts b/packages/host-adapter/codex-cdp/src/connection.ts
index 0951d8e..0ebef2d 100644
--- a/packages/host-adapter/codex-cdp/src/connection.ts
+++ b/packages/host-adapter/codex-cdp/src/connection.ts
@@ -5,6 +5,7 @@ import type {
   NativeHostAction,
   SurfaceDescriptor,
 } from '@codex-git/host-adapter';
+import { isNativeHostAction } from '@codex-git/host-adapter';
 
 import type { CompatibleCodexAnchors } from './compatibility.js';
 import type { CodexRenderer, CspBypassLease } from './renderer.js';
@@ -93,6 +94,10 @@ export class CodexHostConnection implements HostConnection {
     return this.context;
   }
 
+  capabilities() {
+    return { openCodexContext: true, openFileInCodex: false } as const;
+  }
+
   async *contexts(): AsyncIterable<HostContext> {
     const queue = [this.currentContext()];
     let closed = this.closed;
@@ -138,6 +143,11 @@ export class CodexHostConnection implements HostConnection {
       case 'restore-native-surface':
         this.restoreNativeSurface();
         return { status: 'succeeded' };
+      case 'open-codex-context':
+        this.restoreNativeSurface();
+        return { status: 'succeeded' };
+      case 'open-file-in-codex':
+        return { status: 'unsupported' };
     }
   }
 
@@ -327,8 +337,7 @@ function isHostActionMessage(value: unknown): value is {
     typeof candidate.capability === 'string' &&
     typeof candidate.challenge === 'string' &&
     Number.isSafeInteger(candidate.generation) &&
-    typeof action === 'object' &&
-    action !== null &&
-    (action as Record<string, unknown>).kind === 'restore-native-surface'
+    isNativeHostAction(action) &&
+    action.kind === 'restore-native-surface'
   );
 }
diff --git a/packages/host-adapter/codex-cdp/src/dedicated-adapter.ts b/packages/host-adapter/codex-cdp/src/dedicated-adapter.ts
index 52576ab..5b9a469 100644
--- a/packages/host-adapter/codex-cdp/src/dedicated-adapter.ts
+++ b/packages/host-adapter/codex-cdp/src/dedicated-adapter.ts
@@ -133,6 +133,10 @@ class ManagedDedicatedConnection implements HostConnection {
     return this.context;
   }
 
+  capabilities() {
+    return { openCodexContext: true, openFileInCodex: false } as const;
+  }
+
   contexts(): AsyncIterable<HostContext> {
     return this.contextStream.read(this.context);
   }
diff --git a/packages/host-adapter/codex-cdp/src/remote-renderer.ts b/packages/host-adapter/codex-cdp/src/remote-renderer.ts
index 8e414f7..af642fa 100644
--- a/packages/host-adapter/codex-cdp/src/remote-renderer.ts
+++ b/packages/host-adapter/codex-cdp/src/remote-renderer.ts
@@ -152,7 +152,10 @@ class RemoteDedicatedRendererConnection implements DedicatedRendererConnection {
     if (this.closed) {
       return { status: 'rejected' };
     }
-    if (action.kind === 'restore-native-surface') {
+    if (
+      action.kind === 'restore-native-surface' ||
+      action.kind === 'open-codex-context'
+    ) {
       await evaluate(this.session, 'globalThis.__codexGitBridge?.restore()');
       this.open = false;
       return { status: 'succeeded' };
diff --git a/packages/host-adapter/package.json b/packages/host-adapter/package.json
index e947acb..a3245bd 100644
--- a/packages/host-adapter/package.json
+++ b/packages/host-adapter/package.json
@@ -3,5 +3,6 @@
   "version": "0.0.0",
   "private": true,
   "type": "module",
+  "exports": "./src/index.ts",
   "types": "./src/index.ts"
 }
diff --git a/packages/host-adapter/src/index.ts b/packages/host-adapter/src/index.ts
index 95c8a7e..fa36df4 100644
--- a/packages/host-adapter/src/index.ts
+++ b/packages/host-adapter/src/index.ts
@@ -14,12 +14,39 @@ export interface HostTaskContext {
   readonly title: string;
 }
 
-export type NativeHostAction = { readonly kind: 'restore-native-surface' };
+export type NativeHostAction =
+  | { readonly kind: 'restore-native-surface' }
+  | {
+      readonly kind: 'open-codex-context' | 'open-file-in-codex';
+      readonly targetId: string;
+    };
+
+const nativeTargetPattern = /^native_[0-9a-f]{32}$/u;
+
+export function isNativeHostAction(value: unknown): value is NativeHostAction {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value as Record<string, unknown>;
+  if (candidate.kind === 'restore-native-surface') {
+    return Object.keys(candidate).length === 1;
+  }
+  return (
+    (candidate.kind === 'open-codex-context' ||
+      candidate.kind === 'open-file-in-codex') &&
+    typeof candidate.targetId === 'string' &&
+    nativeTargetPattern.test(candidate.targetId) &&
+    Object.keys(candidate).length === 2
+  );
+}
 
 export interface NativeActionResult {
   readonly status: 'succeeded' | 'rejected' | 'unsupported';
 }
 
+export interface HostCapabilities {
+  readonly openCodexContext: boolean;
+  readonly openFileInCodex: boolean;
+}
+
 export interface SanitizedDiagnostic {
   readonly code: 'attach-failed' | 'host-unavailable' | 'incompatible-host';
   readonly message: string;
@@ -37,6 +64,7 @@ export type HostAttachResult =
     };
 
 export interface HostConnection {
+  capabilities(): HostCapabilities;
   currentContext(): HostContext;
   contexts(): AsyncIterable<HostContext>;
   transitions(): AsyncIterable<HostTransition>;
diff --git a/packages/host-adapter/standalone/src/adapter.ts b/packages/host-adapter/standalone/src/adapter.ts
index 8d19dd1..e67addd 100644
--- a/packages/host-adapter/standalone/src/adapter.ts
+++ b/packages/host-adapter/standalone/src/adapter.ts
@@ -13,6 +13,10 @@ const standaloneContext = {
 } satisfies HostContext;
 
 class StandaloneHostConnection implements HostConnection {
+  capabilities() {
+    return { openCodexContext: false, openFileInCodex: false } as const;
+  }
+
   currentContext(): HostContext {
     return standaloneContext;
   }
diff --git a/packages/protocol/src/schemas.ts b/packages/protocol/src/schemas.ts
index 632599e..023d9a4 100644
--- a/packages/protocol/src/schemas.ts
+++ b/packages/protocol/src/schemas.ts
@@ -191,6 +191,18 @@ export const worktreeStatusSchema = z.discriminatedUnion('kind', [
   }),
 ]);
 
+export const worktreeProvenanceSchema = z.discriminatedUnion('kind', [
+  z.strictObject({
+    kind: z.literal('codex_task'),
+    title: z.string().min(1).max(1_024),
+    status: z.string().min(1).max(128),
+  }),
+  z.strictObject({ kind: z.literal('scheduled') }),
+  z.strictObject({ kind: z.literal('permanent') }),
+  z.strictObject({ kind: z.literal('external') }),
+  z.strictObject({ kind: z.literal('unclassified') }),
+]);
+
 export const operationSummarySchema = z.strictObject({
   operationId: operationIdSchema,
   category: z.enum([
@@ -263,6 +275,7 @@ export const worktreeSnapshotSchema = z.strictObject({
   head: headStateSchema,
   indexTree: objectIdSchema.nullable(),
   status: worktreeStatusSchema,
+  provenance: worktreeProvenanceSchema,
   upstream: upstreamOverviewSchema,
   changes: z.array(changedFileSchema).max(2_000).readonly(),
   nativeTargets: z.array(nativeTargetDescriptorSchema).readonly(),
diff --git a/packages/repository-engine/src/index.ts b/packages/repository-engine/src/index.ts
index 015c7a6..68f908b 100644
--- a/packages/repository-engine/src/index.ts
+++ b/packages/repository-engine/src/index.ts
@@ -5,8 +5,16 @@ export {
   type GitLockState,
   type RepositoryDiscovery,
   type RepositoryEngine,
+  type RepositoryEngineOptions,
   type WorktreeAvailability,
 } from './repository-engine.js';
+export {
+  resolveWorktreeProvenance,
+  type CodexMetadataAdapter,
+  type CodexTaskMetadata,
+  type CodexWorktreeMetadata,
+  type WorktreeProvenance,
+} from './worktree-provenance.js';
 export {
   type ChangedFileObservation,
   type InProgressGitOperation,
@@ -30,9 +38,9 @@ export {
 } from './repository-publication.js';
 export {
   type FileNativeTarget,
+  type WorktreeNativeTarget,
   type RemoteFetchResult,
   type RepositoryFetchRequest,
   type RepositorySession,
-  type WorktreeNativeTarget,
   RepositoryTargetFailure,
 } from './repository-session.js';
diff --git a/packages/repository-engine/src/observation-publication.ts b/packages/repository-engine/src/observation-publication.ts
index a06235f..d58afb9 100644
--- a/packages/repository-engine/src/observation-publication.ts
+++ b/packages/repository-engine/src/observation-publication.ts
@@ -14,6 +14,7 @@ import type {
 } from './repository-observation.js';
 import type { FileId, NativeTargetId } from '@codex-git/protocol';
 import type { RemoteSnapshot } from './remote-observation.js';
+import type { WorktreeProvenance } from './worktree-provenance.js';
 
 export interface PublishedRepositoryObservation {
   readonly refs: readonly RefSnapshot[];
@@ -27,16 +28,17 @@ export const privateWorktreeIdentityEvidence = Symbol(
 
 export interface PublishedObservationWorktree extends Omit<
   DiscoveredWorktree,
-  'canonicalPathBytes' | 'privateIdentityEvidence'
+  'canonicalPathBytes' | 'privateIdentityEvidence' | 'provenance'
 > {
-  readonly nativeTargetId: NativeTargetId;
   readonly [privateWorktreeIdentityEvidence]?: string;
   readonly worktreeRevision: number;
+  readonly nativeTargetId: NativeTargetId | null;
   readonly freshness: WorktreeFreshness;
   readonly index: IndexSnapshot | null;
   readonly status: WorktreeStatusSummary | null;
   readonly changes: readonly PublishedChangedFile[];
   readonly upstream: UpstreamSnapshot;
+  readonly provenance: WorktreeProvenance;
 }
 
 export type PublishedChangedFile = ChangedFileObservation & {
@@ -112,9 +114,13 @@ export function publishObservedFacts(
         : publishWorktreeObservation(worktree, observed, prior);
     const candidate: Omit<
       PublishedObservationWorktree,
-      'nativeTargetId' | 'worktreeRevision' | 'changes'
+      'worktreeRevision' | 'changes'
     > & { readonly changes: readonly ChangedFileObservation[] } = {
       worktreeId: worktree.worktreeId,
+      nativeTargetId:
+        prior?.generation === worktree.generation
+          ? prior.nativeTargetId
+          : (issueNativeTargetId?.() ?? null),
       generation: worktree.generation,
       [privateWorktreeIdentityEvidence]: worktree.privateIdentityEvidence,
       displayPath: worktree.displayPath,
@@ -123,18 +129,23 @@ export function publishObservedFacts(
       head: observedFacts.head,
       gitLock: worktree.gitLock,
       availability: worktree.availability,
+      provenance: worktree.provenance ?? { kind: 'unclassified' },
       freshness: observedFacts.freshness,
       index: observedFacts.index,
       status: observedFacts.status,
       changes: observedFacts.changes,
       upstream: observedFacts.upstream,
     };
-    const changed =
+    const gitFactsChanged =
       prior === undefined ||
       worktreeEvidence(candidate) !== worktreeEvidence(prior);
+    const provenanceChanged =
+      prior === undefined ||
+      JSON.stringify(candidate.provenance) !== JSON.stringify(prior.provenance);
+    const changed = gitFactsChanged || provenanceChanged;
     worktreeChanged ||= changed;
     const changes =
-      !changed && prior !== undefined
+      !gitFactsChanged && prior !== undefined
         ? prior.changes
         : observedFacts.changes.map((change) =>
             publishedChangedFile(
diff --git a/packages/repository-engine/src/repository-engine.ts b/packages/repository-engine/src/repository-engine.ts
index e5d9baf..5d9efbc 100644
--- a/packages/repository-engine/src/repository-engine.ts
+++ b/packages/repository-engine/src/repository-engine.ts
@@ -38,6 +38,11 @@ import {
   createRemoteIdentityState,
   type RemoteIdentityState,
 } from './remote-observation.js';
+import {
+  resolveWorktreeProvenance,
+  type CodexMetadataAdapter,
+  type WorktreeProvenance,
+} from './worktree-provenance.js';
 
 const GIT_OUTPUT_LIMIT_BYTES = 4 * 1_024 * 1_024;
 const GIT_TIMEOUT_MILLISECONDS = 10_000;
@@ -63,6 +68,7 @@ export interface DiscoveredWorktree {
   readonly head: DiscoveredHead;
   readonly gitLock: GitLockState;
   readonly availability: WorktreeAvailability;
+  readonly provenance?: WorktreeProvenance;
 }
 
 export type DiscoveredHead =
@@ -124,7 +130,13 @@ interface CanonicalRegistration {
   readonly unavailableReason: string | null;
 }
 
-export function createRepositoryEngine(): RepositoryEngine {
+export interface RepositoryEngineOptions {
+  readonly metadata?: CodexMetadataAdapter;
+}
+
+export function createRepositoryEngine(
+  options: RepositoryEngineOptions = {},
+): RepositoryEngine {
   return {
     async open(anchor) {
       const resolved = await resolveAnchor(anchor);
@@ -200,6 +212,11 @@ export function createRepositoryEngine(): RepositoryEngine {
             : { kind: 'all' };
           const worktreeIds =
             scope.kind === 'all' ? undefined : new Set(scope.worktreeIds);
+          discovery = await attachProvenance(
+            discovery,
+            options.metadata,
+            signal,
+          );
           const observation = await createRepositoryObserver(
             runGit,
             ids,
@@ -247,6 +264,29 @@ export function createRepositoryEngine(): RepositoryEngine {
   };
 }
 
+async function attachProvenance(
+  discovery: RepositoryDiscovery,
+  adapter: CodexMetadataAdapter | undefined,
+  signal: AbortSignal,
+): Promise<RepositoryDiscovery> {
+  let metadata: Awaited<ReturnType<CodexMetadataAdapter['read']>> = [];
+  try {
+    metadata = (await adapter?.read(signal)) ?? [];
+  } catch {
+    // Optional host metadata must never make Git inventory unavailable.
+  }
+  return {
+    ...discovery,
+    worktrees: discovery.worktrees.map((worktree) => ({
+      ...worktree,
+      provenance:
+        worktree.canonicalPath === null
+          ? { kind: 'unclassified' as const }
+          : resolveWorktreeProvenance(worktree.canonicalPath, metadata),
+    })),
+  };
+}
+
 async function discoverRepository(
   resolved: ResolvedAnchor,
   identity: RepositoryIdentityState,
diff --git a/packages/repository-engine/src/repository-session-remote-operation.test.ts b/packages/repository-engine/src/repository-session-remote-operation.test.ts
new file mode 100644
index 0000000..19c7b69
--- /dev/null
+++ b/packages/repository-engine/src/repository-session-remote-operation.test.ts
@@ -0,0 +1,283 @@
+import { describe, expect, it } from 'vitest';
+
+import type { AbsolutePath, ClientCommandId } from '@codex-git/protocol';
+
+import type { ScopedRepositoryPublicationSession } from './repository-publication.js';
+import { createRepositorySession } from './repository-session.js';
+
+describe('Repository Remote operation outcomes', () => {
+  it('reports Push success when exact refreshed state proves the effect despite an earlier failure diagnostic', async () => {
+    const beforePush = remoteRepositoryFixture();
+    const afterPush = pushedRepositoryFixture();
+    let pushed = false;
+    const delegate = {
+      snapshot: async () => (pushed ? afterPush : beforePush),
+      requestRefresh: async () => (pushed ? afterPush : beforePush),
+      requestScopedRefresh: async () => (pushed ? afterPush : beforePush),
+      close: async () => undefined,
+    } as unknown as ScopedRepositoryPublicationSession;
+    const session = createRepositorySession(delegate, {
+      runGit: async () => new TextEncoder().encode('origin\0refs/heads/main\n'),
+      executeRemoteOperation: async (request) => {
+        if (request.kind === 'push') {
+          return {
+            kind: 'failed_known',
+            code: 'offline',
+            message: 'The Remote could not be reached.',
+          };
+        }
+        pushed = true;
+        return { kind: 'completed' };
+      },
+    });
+    const opened = await session.requestRefresh();
+    if (opened.kind !== 'repository') throw new Error('Expected Repository.');
+    const worktree = opened.repository.worktrees[0]!;
+
+    const receipt = await session.dispatch({
+      clientCommandId:
+        'command_00000000000000000000000000000003' as ClientCommandId,
+      command: {
+        kind: 'push',
+        worktreeId: worktree.worktreeId,
+        expectedWorktreeRevision: worktree.worktreeRevision,
+        expectedRefsRevision: opened.repository.refsRevision,
+      },
+    });
+    const result = await session.recoverOperation(receipt.operationId);
+
+    expect(result).toMatchObject({
+      kind: 'succeeded',
+      result: { kind: 'remote', summary: 'Pushed main.' },
+    });
+    await session.close();
+  });
+
+  it('keeps matching offline diagnostics unknown without refreshed-state proof', async () => {
+    const repository = remoteRepositoryFixture();
+    const delegate = {
+      snapshot: async () => repository,
+      requestRefresh: async () => repository,
+      requestScopedRefresh: async () => repository,
+      close: async () => undefined,
+    } as unknown as ScopedRepositoryPublicationSession;
+    const session = createRepositorySession(delegate, {
+      runGit: async () => new TextEncoder().encode('origin\0refs/heads/main\n'),
+      executeRemoteOperation: async () => ({
+        kind: 'failed_known',
+        code: 'offline',
+        message: 'The Remote could not be reached.',
+      }),
+    });
+    const opened = await session.requestRefresh();
+    if (opened.kind !== 'repository') throw new Error('Expected Repository.');
+    const worktree = opened.repository.worktrees[0]!;
+
+    const receipt = await session.dispatch({
+      clientCommandId:
+        'command_00000000000000000000000000000004' as ClientCommandId,
+      command: {
+        kind: 'push',
+        worktreeId: worktree.worktreeId,
+        expectedWorktreeRevision: worktree.worktreeRevision,
+        expectedRefsRevision: opened.repository.refsRevision,
+      },
+    });
+    const result = await session.recoverOperation(receipt.operationId);
+
+    expect(result).toMatchObject({
+      kind: 'unknown_outcome',
+      code: 'reconciliation_incomplete',
+      recoveryAvailable: true,
+    });
+    await session.close();
+  });
+
+  it('keeps an ambiguous Push unknown when exact Remote reconciliation also cannot complete', async () => {
+    const repository = remoteRepositoryFixture();
+    const delegate = {
+      snapshot: async () => repository,
+      requestRefresh: async () => repository,
+      requestScopedRefresh: async () => repository,
+      close: async () => undefined,
+    } as unknown as ScopedRepositoryPublicationSession;
+    const session = createRepositorySession(delegate, {
+      runGit: async () => new TextEncoder().encode('origin\0refs/heads/main\n'),
+      executeRemoteOperation: async () => ({
+        kind: 'unknown',
+        message: 'Git did not report an unambiguous Remote Operation outcome.',
+      }),
+    });
+    const opened = await session.requestRefresh();
+    if (opened.kind !== 'repository') throw new Error('Expected Repository.');
+    const worktree = opened.repository.worktrees[0]!;
+
+    const receipt = await session.dispatch({
+      clientCommandId:
+        'command_00000000000000000000000000000001' as ClientCommandId,
+      command: {
+        kind: 'push',
+        worktreeId: worktree.worktreeId,
+        expectedWorktreeRevision: worktree.worktreeRevision,
+        expectedRefsRevision: opened.repository.refsRevision,
+      },
+    });
+    const result = await session.recoverOperation(receipt.operationId);
+
+    expect(result).toMatchObject({
+      kind: 'unknown_outcome',
+      code: 'reconciliation_incomplete',
+      recoveryAvailable: true,
+    });
+    await session.close();
+  });
+
+  it('reconciles exact Remote state after an executor throws', async () => {
+    const repository = remoteRepositoryFixture();
+    const delegate = {
+      snapshot: async () => repository,
+      requestRefresh: async () => repository,
+      requestScopedRefresh: async () => repository,
+      close: async () => undefined,
+    } as unknown as ScopedRepositoryPublicationSession;
+    const requests: string[] = [];
+    const session = createRepositorySession(delegate, {
+      runGit: async () => new TextEncoder().encode('origin\0refs/heads/main\n'),
+      executeRemoteOperation: async (request) => {
+        requests.push(request.kind);
+        if (request.kind === 'push') throw new Error('ambiguous process loss');
+        return { kind: 'completed' };
+      },
+    });
+    const opened = await session.requestRefresh();
+    if (opened.kind !== 'repository') throw new Error('Expected Repository.');
+    const worktree = opened.repository.worktrees[0]!;
+
+    const receipt = await session.dispatch({
+      clientCommandId:
+        'command_00000000000000000000000000000002' as ClientCommandId,
+      command: {
+        kind: 'push',
+        worktreeId: worktree.worktreeId,
+        expectedWorktreeRevision: worktree.worktreeRevision,
+        expectedRefsRevision: opened.repository.refsRevision,
+      },
+    });
+    const result = await session.recoverOperation(receipt.operationId);
+
+    expect(requests[0]).toBe('push');
+    expect(requests.slice(1)).not.toHaveLength(0);
+    expect(requests.slice(1)).toEqual(
+      requests.slice(1).map(() => 'refresh_tracking'),
+    );
+    expect(result).toMatchObject({
+      kind: 'unknown_outcome',
+      code: 'reconciliation_incomplete',
+    });
+    await session.close();
+  });
+});
+
+function remoteRepositoryFixture() {
+  const repositoryId = 'repository_00000000000000000000000000000001' as const;
+  const worktreeId = 'worktree_00000000000000000000000000000001' as const;
+  const generation = 'generation_00000000000000000000000000000001' as const;
+  const remoteId = 'remote_00000000000000000000000000000001' as const;
+  const objectId = '0123456789abcdef0123456789abcdef01234567';
+  return {
+    kind: 'repository' as const,
+    repository: {
+      repositoryId,
+      repositoryRevision: 1,
+      topologyRevision: 1,
+      refsRevision: 1,
+      refresh: { kind: 'fresh' as const },
+      fetch: { kind: 'never' as const },
+      operations: [],
+      commonGitDirectory: '/projects/repository/.git' as AbsolutePath,
+      selectedWorktreeId: worktreeId,
+      refs: [
+        { kind: 'local' as const, fullName: 'refs/heads/main', objectId },
+        {
+          kind: 'remote_tracking' as const,
+          fullName: 'refs/remotes/origin/main',
+          objectId: '1123456789abcdef0123456789abcdef01234567',
+        },
+      ],
+      remotes: [
+        {
+          remoteId,
+          displayName: 'origin',
+          host: 'example.test',
+          configurationEvidence: 'configured-origin',
+        },
+      ],
+      worktrees: [
+        {
+          worktreeId,
+          worktreeRevision: 1,
+          generation,
+          displayPath: '/projects/repository',
+          canonicalPath: '/projects/repository' as AbsolutePath,
+          role: 'main' as const,
+          head: {
+            kind: 'local_branch' as const,
+            fullName: 'refs/heads/main',
+            displayName: 'main',
+            objectId,
+          },
+          gitLock: { kind: 'unlocked' as const },
+          availability: { kind: 'available' as const },
+          freshness: { kind: 'fresh' as const },
+          index: { entryCount: 1, fingerprint: 'index', locked: false },
+          status: {
+            clean: true,
+            conflicted: 0,
+            staged: 0,
+            unstaged: 0,
+            untracked: 0,
+          },
+          changes: [],
+          upstream: {
+            kind: 'tracking' as const,
+            remoteId,
+            displayName: 'origin/main',
+            ref: {
+              kind: 'remote_tracking' as const,
+              fullName: 'refs/remotes/origin/main',
+              objectId: '1123456789abcdef0123456789abcdef01234567',
+            },
+            aheadBehind: { kind: 'cached' as const, ahead: 1, behind: 0 },
+          },
+        },
+      ],
+    },
+  };
+}
+
+function pushedRepositoryFixture() {
+  const fixture = remoteRepositoryFixture();
+  const localObjectId = fixture.repository.worktrees[0]!.head.objectId!;
+  return {
+    ...fixture,
+    repository: {
+      ...fixture.repository,
+      repositoryRevision: fixture.repository.repositoryRevision + 1,
+      refsRevision: fixture.repository.refsRevision + 1,
+      refs: fixture.repository.refs.map((ref) =>
+        ref.kind === 'remote_tracking'
+          ? { ...ref, objectId: localObjectId }
+          : ref,
+      ),
+      worktrees: fixture.repository.worktrees.map((worktree) => ({
+        ...worktree,
+        worktreeRevision: worktree.worktreeRevision + 1,
+        upstream: {
+          ...worktree.upstream,
+          ref: { ...worktree.upstream.ref, objectId: localObjectId },
+          aheadBehind: { kind: 'cached' as const, ahead: 0, behind: 0 },
+        },
+      })),
+    },
+  };
+}
diff --git a/packages/repository-engine/src/repository-session.test.ts b/packages/repository-engine/src/repository-session.test.ts
index e6e568a..1018164 100644
--- a/packages/repository-engine/src/repository-session.test.ts
+++ b/packages/repository-engine/src/repository-session.test.ts
@@ -1,10 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import type {
-  AbsolutePath,
-  ClientCommandId,
-  NativeTargetId,
-} from '@codex-git/protocol';
+import type { NativeTargetId } from '@codex-git/protocol';
 
 import type { ScopedRepositoryPublicationSession } from './repository-publication.js';
 import { createRepositorySession } from './repository-session.js';
@@ -26,6 +22,7 @@ describe('Repository File native targets', () => {
         worktrees: [
           {
             canonicalPath: '/projects/repository',
+            provenance: { kind: 'unclassified' },
             changes: [
               {
                 nativeTargetId: targetId,
@@ -49,6 +46,7 @@ describe('Repository File native targets', () => {
       absolutePath: null,
       canOpen: false,
       relativePath: '\\xff.txt',
+      provenance: { kind: 'unclassified' },
       worktreePath: '/projects/repository',
     });
 
@@ -57,7 +55,7 @@ describe('Repository File native targets', () => {
 });
 
 describe('Repository Worktree native targets', () => {
-  it('resolves only the exact fresh and available Worktree target', async () => {
+  it('resolves an exact opaque Worktree target with current generation facts', async () => {
     const targetId =
       'native_00000000000000000000000000000002' as NativeTargetId;
     const repository = {
@@ -73,9 +71,18 @@ describe('Repository Worktree native targets', () => {
         worktrees: [
           {
             nativeTargetId: targetId,
-            canonicalPath: '/projects/selected-worktree',
+            worktreeId: 'worktree_fixture',
+            generation: 'generation_fixture',
+            canonicalPath: '/projects/exact-worktree',
+            displayPath: '/projects/exact-worktree',
             availability: { kind: 'available' },
-            freshness: { kind: 'fresh' },
+            provenance: { kind: 'unclassified' },
+            head: {
+              kind: 'local_branch',
+              displayName: 'feat/exact-target',
+              fullName: 'refs/heads/feat/exact-target',
+              objectId: '1'.repeat(40),
+            },
             changes: [],
           },
         ],
@@ -92,286 +99,13 @@ describe('Repository Worktree native targets', () => {
     await expect(
       session.resolveWorktreeNativeTarget(targetId),
     ).resolves.toEqual({
-      worktreePath: '/projects/selected-worktree',
+      absolutePath: '/projects/exact-worktree',
+      branchOrSha: 'feat/exact-target',
+      canLaunch: true,
+      provenance: { kind: 'unclassified' },
+      worktreePath: '/projects/exact-worktree',
     });
 
     await session.close();
   });
 });
-
-describe('Repository Remote operation outcomes', () => {
-  it('reports Push success when exact refreshed state proves the effect despite an earlier failure diagnostic', async () => {
-    const beforePush = remoteRepositoryFixture();
-    const afterPush = pushedRepositoryFixture();
-    let pushed = false;
-    const delegate = {
-      snapshot: async () => (pushed ? afterPush : beforePush),
-      requestRefresh: async () => (pushed ? afterPush : beforePush),
-      requestScopedRefresh: async () => (pushed ? afterPush : beforePush),
-      close: async () => undefined,
-    } as unknown as ScopedRepositoryPublicationSession;
-    const session = createRepositorySession(delegate, {
-      runGit: async () => new TextEncoder().encode('origin\0refs/heads/main\n'),
-      executeRemoteOperation: async (request) => {
-        if (request.kind === 'push') {
-          return {
-            kind: 'failed_known',
-            code: 'offline',
-            message: 'The Remote could not be reached.',
-          };
-        }
-        pushed = true;
-        return { kind: 'completed' };
-      },
-    });
-    const opened = await session.requestRefresh();
-    if (opened.kind !== 'repository') throw new Error('Expected Repository.');
-    const worktree = opened.repository.worktrees[0]!;
-
-    const receipt = await session.dispatch({
-      clientCommandId:
-        'command_00000000000000000000000000000003' as ClientCommandId,
-      command: {
-        kind: 'push',
-        worktreeId: worktree.worktreeId,
-        expectedWorktreeRevision: worktree.worktreeRevision,
-        expectedRefsRevision: opened.repository.refsRevision,
-      },
-    });
-    const result = await session.recoverOperation(receipt.operationId);
-
-    expect(result).toMatchObject({
-      kind: 'succeeded',
-      result: { kind: 'remote', summary: 'Pushed main.' },
-    });
-    await session.close();
-  });
-
-  it('keeps matching offline diagnostics unknown without refreshed-state proof', async () => {
-    const repository = remoteRepositoryFixture();
-    const delegate = {
-      snapshot: async () => repository,
-      requestRefresh: async () => repository,
-      requestScopedRefresh: async () => repository,
-      close: async () => undefined,
-    } as unknown as ScopedRepositoryPublicationSession;
-    const session = createRepositorySession(delegate, {
-      runGit: async () => new TextEncoder().encode('origin\0refs/heads/main\n'),
-      executeRemoteOperation: async () => ({
-        kind: 'failed_known',
-        code: 'offline',
-        message: 'The Remote could not be reached.',
-      }),
-    });
-    const opened = await session.requestRefresh();
-    if (opened.kind !== 'repository') throw new Error('Expected Repository.');
-    const worktree = opened.repository.worktrees[0]!;
-
-    const receipt = await session.dispatch({
-      clientCommandId:
-        'command_00000000000000000000000000000004' as ClientCommandId,
-      command: {
-        kind: 'push',
-        worktreeId: worktree.worktreeId,
-        expectedWorktreeRevision: worktree.worktreeRevision,
-        expectedRefsRevision: opened.repository.refsRevision,
-      },
-    });
-    const result = await session.recoverOperation(receipt.operationId);
-
-    expect(result).toMatchObject({
-      kind: 'unknown_outcome',
-      code: 'reconciliation_incomplete',
-      recoveryAvailable: true,
-    });
-    await session.close();
-  });
-
-  it('keeps an ambiguous Push unknown when exact Remote reconciliation also cannot complete', async () => {
-    const repository = remoteRepositoryFixture();
-    const delegate = {
-      snapshot: async () => repository,
-      requestRefresh: async () => repository,
-      requestScopedRefresh: async () => repository,
-      close: async () => undefined,
-    } as unknown as ScopedRepositoryPublicationSession;
-    const session = createRepositorySession(delegate, {
-      runGit: async () => new TextEncoder().encode('origin\0refs/heads/main\n'),
-      executeRemoteOperation: async () => ({
-        kind: 'unknown',
-        message: 'Git did not report an unambiguous Remote Operation outcome.',
-      }),
-    });
-    const opened = await session.requestRefresh();
-    if (opened.kind !== 'repository') throw new Error('Expected Repository.');
-    const worktree = opened.repository.worktrees[0]!;
-
-    const receipt = await session.dispatch({
-      clientCommandId:
-        'command_00000000000000000000000000000001' as ClientCommandId,
-      command: {
-        kind: 'push',
-        worktreeId: worktree.worktreeId,
-        expectedWorktreeRevision: worktree.worktreeRevision,
-        expectedRefsRevision: opened.repository.refsRevision,
-      },
-    });
-    const result = await session.recoverOperation(receipt.operationId);
-
-    expect(result).toMatchObject({
-      kind: 'unknown_outcome',
-      code: 'reconciliation_incomplete',
-      recoveryAvailable: true,
-    });
-    await session.close();
-  });
-
-  it('reconciles exact Remote state after an executor throws', async () => {
-    const repository = remoteRepositoryFixture();
-    const delegate = {
-      snapshot: async () => repository,
-      requestRefresh: async () => repository,
-      requestScopedRefresh: async () => repository,
-      close: async () => undefined,
-    } as unknown as ScopedRepositoryPublicationSession;
-    const requests: string[] = [];
-    const session = createRepositorySession(delegate, {
-      runGit: async () => new TextEncoder().encode('origin\0refs/heads/main\n'),
-      executeRemoteOperation: async (request) => {
-        requests.push(request.kind);
-        if (request.kind === 'push') throw new Error('ambiguous process loss');
-        return { kind: 'completed' };
-      },
-    });
-    const opened = await session.requestRefresh();
-    if (opened.kind !== 'repository') throw new Error('Expected Repository.');
-    const worktree = opened.repository.worktrees[0]!;
-
-    const receipt = await session.dispatch({
-      clientCommandId:
-        'command_00000000000000000000000000000002' as ClientCommandId,
-      command: {
-        kind: 'push',
-        worktreeId: worktree.worktreeId,
-        expectedWorktreeRevision: worktree.worktreeRevision,
-        expectedRefsRevision: opened.repository.refsRevision,
-      },
-    });
-    const result = await session.recoverOperation(receipt.operationId);
-
-    expect(requests[0]).toBe('push');
-    expect(requests.slice(1)).not.toHaveLength(0);
-    expect(requests.slice(1)).toEqual(
-      requests.slice(1).map(() => 'refresh_tracking'),
-    );
-    expect(result).toMatchObject({
-      kind: 'unknown_outcome',
-      code: 'reconciliation_incomplete',
-    });
-    await session.close();
-  });
-});
-
-function remoteRepositoryFixture() {
-  const repositoryId = 'repository_00000000000000000000000000000001' as const;
-  const worktreeId = 'worktree_00000000000000000000000000000001' as const;
-  const generation = 'generation_00000000000000000000000000000001' as const;
-  const remoteId = 'remote_00000000000000000000000000000001' as const;
-  const objectId = '0123456789abcdef0123456789abcdef01234567';
-  return {
-    kind: 'repository' as const,
-    repository: {
-      repositoryId,
-      repositoryRevision: 1,
-      topologyRevision: 1,
-      refsRevision: 1,
-      refresh: { kind: 'fresh' as const },
-      fetch: { kind: 'never' as const },
-      operations: [],
-      commonGitDirectory: '/projects/repository/.git' as AbsolutePath,
-      selectedWorktreeId: worktreeId,
-      refs: [
-        { kind: 'local' as const, fullName: 'refs/heads/main', objectId },
-        {
-          kind: 'remote_tracking' as const,
-          fullName: 'refs/remotes/origin/main',
-          objectId: '1123456789abcdef0123456789abcdef01234567',
-        },
-      ],
-      remotes: [
-        {
-          remoteId,
-          displayName: 'origin',
-          host: 'example.test',
-          configurationEvidence: 'configured-origin',
-        },
-      ],
-      worktrees: [
-        {
-          worktreeId,
-          worktreeRevision: 1,
-          generation,
-          displayPath: '/projects/repository',
-          canonicalPath: '/projects/repository' as AbsolutePath,
-          role: 'main' as const,
-          head: {
-            kind: 'local_branch' as const,
-            fullName: 'refs/heads/main',
-            displayName: 'main',
-            objectId,
-          },
-          gitLock: { kind: 'unlocked' as const },
-          availability: { kind: 'available' as const },
-          freshness: { kind: 'fresh' as const },
-          index: { entryCount: 1, fingerprint: 'index', locked: false },
-          status: {
-            clean: true,
-            conflicted: 0,
-            staged: 0,
-            unstaged: 0,
-            untracked: 0,
-          },
-          changes: [],
-          upstream: {
-            kind: 'tracking' as const,
-            remoteId,
-            displayName: 'origin/main',
-            ref: {
-              kind: 'remote_tracking' as const,
-              fullName: 'refs/remotes/origin/main',
-              objectId: '1123456789abcdef0123456789abcdef01234567',
-            },
-            aheadBehind: { kind: 'cached' as const, ahead: 1, behind: 0 },
-          },
-        },
-      ],
-    },
-  };
-}
-
-function pushedRepositoryFixture() {
-  const fixture = remoteRepositoryFixture();
-  const localObjectId = fixture.repository.worktrees[0]!.head.objectId!;
-  return {
-    ...fixture,
-    repository: {
-      ...fixture.repository,
-      repositoryRevision: fixture.repository.repositoryRevision + 1,
-      refsRevision: fixture.repository.refsRevision + 1,
-      refs: fixture.repository.refs.map((ref) =>
-        ref.kind === 'remote_tracking'
-          ? { ...ref, objectId: localObjectId }
-          : ref,
-      ),
-      worktrees: fixture.repository.worktrees.map((worktree) => ({
-        ...worktree,
-        worktreeRevision: worktree.worktreeRevision + 1,
-        upstream: {
-          ...worktree.upstream,
-          ref: { ...worktree.upstream.ref, objectId: localObjectId },
-          aheadBehind: { kind: 'cached' as const, ahead: 0, behind: 0 },
-        },
-      })),
-    },
-  };
-}
diff --git a/packages/repository-engine/src/repository-session.ts b/packages/repository-engine/src/repository-session.ts
index 2a03e1e..6d42fc6 100644
--- a/packages/repository-engine/src/repository-session.ts
+++ b/packages/repository-engine/src/repository-session.ts
@@ -34,6 +34,7 @@ import type {
   RepositorySnapshot,
   ScopedRepositoryPublicationSession,
 } from './repository-publication.js';
+import type { WorktreeProvenance } from './worktree-provenance.js';
 import { privateWorktreeIdentityEvidence } from './observation-publication.js';
 
 const OPERATION_TIMEOUT_MILLISECONDS = 30_000;
@@ -111,6 +112,15 @@ export interface FileNativeTarget {
   readonly absolutePath: string | null;
   readonly canOpen: boolean;
   readonly relativePath: string;
+  readonly provenance: WorktreeProvenance;
+  readonly worktreePath: string;
+}
+
+export interface WorktreeNativeTarget {
+  readonly absolutePath: string;
+  readonly branchOrSha: string;
+  readonly canLaunch: boolean;
+  readonly provenance: WorktreeProvenance;
   readonly worktreePath: string;
 }
 
@@ -1249,6 +1259,7 @@ export function createRepositorySession(
             absolutePath: null,
             canOpen: false,
             relativePath: escapedBytePath(change.pathBytes),
+            provenance: worktree.provenance,
             worktreePath: worktree.canonicalPath,
           };
         }
@@ -1261,6 +1272,7 @@ export function createRepositorySession(
             absolutePath,
             canOpen: change.workingFilePresent,
             relativePath,
+            provenance: worktree.provenance,
             worktreePath: worktree.canonicalPath,
           };
         }
@@ -1274,15 +1286,21 @@ export function createRepositorySession(
       const worktree = result.repository.worktrees.find(
         (candidate) => candidate.nativeTargetId === targetId,
       );
-      if (
-        worktree === undefined ||
-        worktree.canonicalPath === null ||
-        worktree.availability.kind !== 'available' ||
-        worktree.freshness.kind !== 'fresh'
-      ) {
-        throw new RepositoryTargetFailure();
-      }
-      return { worktreePath: worktree.canonicalPath };
+      if (worktree === undefined) throw new RepositoryTargetFailure();
+      const branchOrSha =
+        worktree.head.kind === 'local_branch'
+          ? worktree.head.displayName
+          : worktree.head.objectId;
+      const worktreePath = worktree.canonicalPath ?? worktree.displayPath;
+      return {
+        absolutePath: worktreePath,
+        branchOrSha,
+        canLaunch:
+          worktree.canonicalPath !== null &&
+          worktree.availability.kind === 'available',
+        provenance: worktree.provenance,
+        worktreePath,
+      };
     },
     async searchBranches(request) {
       const observed = await observe(() => delegate.requestRefresh());
diff --git a/packages/repository-engine/src/worktree-provenance.test.ts b/packages/repository-engine/src/worktree-provenance.test.ts
new file mode 100644
index 0000000..175bfad
--- /dev/null
+++ b/packages/repository-engine/src/worktree-provenance.test.ts
@@ -0,0 +1,89 @@
+import { describe, expect, it } from 'vitest';
+
+import { resolveWorktreeProvenance } from './worktree-provenance.js';
+
+describe('Worktree provenance resolver', () => {
+  it('classifies conflicting stable Codex evidence as Unclassified', () => {
+    const result = resolveWorktreeProvenance('/private/tmp/exact-worktree', [
+      {
+        canonicalCwd: '/private/tmp/exact-worktree',
+        kind: 'codex_task',
+        stable: true,
+        task: {
+          id: 'task-17',
+          status: 'active',
+          title: 'Implement exact navigation',
+        },
+      },
+      {
+        canonicalCwd: '/private/tmp/exact-worktree',
+        kind: 'scheduled',
+        stable: true,
+      },
+    ]);
+
+    expect(result).toEqual({ kind: 'unclassified' });
+  });
+
+  it('fails closed on malformed or unstable metadata', () => {
+    expect(
+      resolveWorktreeProvenance('/private/tmp/exact-worktree', [
+        {
+          canonicalCwd: '/private/tmp/exact-worktree',
+          kind: 'codex_task',
+          stable: true,
+          task: {
+            id: 'task-unsafe',
+            status: 'active',
+            title: 'x'.repeat(1_025),
+          },
+        },
+        {
+          canonicalCwd: '/private/tmp/exact-worktree',
+          kind: 'scheduled',
+          stable: false,
+        },
+      ]),
+    ).toEqual({ kind: 'unclassified' });
+  });
+
+  it.each([
+    [
+      'unstable conflicting evidence',
+      {
+        canonicalCwd: '/private/tmp/exact-worktree',
+        kind: 'scheduled',
+        stable: false,
+      },
+    ],
+    [
+      'malformed conflicting evidence',
+      {
+        canonicalCwd: '/private/tmp/exact-worktree',
+        kind: 'codex_task',
+        stable: true,
+      },
+    ],
+  ] as const)(
+    'fails closed on %s beside stable evidence',
+    (_label, conflict) => {
+      const stable = {
+        canonicalCwd: '/private/tmp/exact-worktree',
+        kind: 'codex_task' as const,
+        stable: true,
+        task: {
+          id: 'task-stable',
+          status: 'active',
+          title: 'Stable task',
+        },
+      };
+
+      expect(
+        resolveWorktreeProvenance('/private/tmp/exact-worktree', [
+          stable,
+          conflict as typeof stable,
+        ]),
+      ).toEqual({ kind: 'unclassified' });
+    },
+  );
+});
diff --git a/packages/repository-engine/src/worktree-provenance.ts b/packages/repository-engine/src/worktree-provenance.ts
new file mode 100644
index 0000000..8aa8be2
--- /dev/null
+++ b/packages/repository-engine/src/worktree-provenance.ts
@@ -0,0 +1,95 @@
+import type { AbsolutePath } from '@codex-git/protocol';
+
+export type WorktreeProvenance =
+  | {
+      readonly kind: 'codex_task';
+      readonly task: CodexTaskMetadata;
+    }
+  | { readonly kind: 'scheduled' }
+  | { readonly kind: 'permanent' }
+  | { readonly kind: 'external' }
+  | { readonly kind: 'unclassified' };
+
+export interface CodexTaskMetadata {
+  readonly id: string;
+  readonly status: string;
+  readonly title: string;
+}
+
+export type CodexWorktreeMetadata =
+  | {
+      readonly canonicalCwd: AbsolutePath | string;
+      readonly kind: 'codex_task';
+      readonly stable: boolean;
+      readonly task: CodexTaskMetadata;
+    }
+  | {
+      readonly canonicalCwd: AbsolutePath | string;
+      readonly kind: 'scheduled' | 'permanent' | 'external';
+      readonly stable: boolean;
+    };
+
+export interface CodexMetadataAdapter {
+  read(signal?: AbortSignal): Promise<readonly CodexWorktreeMetadata[]>;
+}
+
+export function resolveWorktreeProvenance(
+  canonicalCwd: AbsolutePath | string,
+  metadata: readonly CodexWorktreeMetadata[],
+): WorktreeProvenance {
+  const exactCwdCandidates = metadata.filter(
+    (candidate) => candidate.canonicalCwd === canonicalCwd,
+  );
+  if (
+    exactCwdCandidates.length === 0 ||
+    exactCwdCandidates.some((candidate) => !isStableMetadata(candidate))
+  ) {
+    return { kind: 'unclassified' };
+  }
+  const stableCandidates =
+    exactCwdCandidates as readonly (CodexWorktreeMetadata & {
+      readonly stable: true;
+    })[];
+  const first = stableCandidates[0]!;
+  if (
+    stableCandidates.some(
+      (candidate) => JSON.stringify(candidate) !== JSON.stringify(first),
+    )
+  ) {
+    return { kind: 'unclassified' };
+  }
+  return first.kind === 'codex_task'
+    ? { kind: first.kind, task: first.task }
+    : { kind: first.kind };
+}
+
+function isStableMetadata(
+  candidate: CodexWorktreeMetadata,
+): candidate is CodexWorktreeMetadata & { readonly stable: true } {
+  if (!candidate.stable) return false;
+  if (
+    candidate.kind !== 'codex_task' &&
+    candidate.kind !== 'scheduled' &&
+    candidate.kind !== 'permanent' &&
+    candidate.kind !== 'external'
+  ) {
+    return false;
+  }
+  if (candidate.kind !== 'codex_task') return true;
+  const task: unknown = candidate.task;
+  if (typeof task !== 'object' || task === null) return false;
+  const fields = task as Record<string, unknown>;
+  return (
+    boundedText(fields.id, 1_024) &&
+    boundedText(fields.status, 128) &&
+    boundedText(fields.title, 1_024)
+  );
+}
+
+function boundedText(value: unknown, maximumLength: number): value is string {
+  return (
+    typeof value === 'string' &&
+    value.trim().length > 0 &&
+    value.length <= maximumLength
+  );
+}
diff --git a/tests/contract/host-adapter.contract.test.ts b/tests/contract/host-adapter.contract.test.ts
index 9fedb39..e4ab86c 100644
--- a/tests/contract/host-adapter.contract.test.ts
+++ b/tests/contract/host-adapter.contract.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 
 import { StandaloneHostAdapter } from '@codex-git/host-adapter-standalone';
+import { isNativeHostAction } from '@codex-git/host-adapter';
 
 describe('HostAdapter contract', () => {
   it('attaches the standalone surface with a current typed Host Context', async () => {
@@ -19,7 +20,34 @@ describe('HostAdapter contract', () => {
       task: null,
       theme: 'system',
     });
+    expect(result.connection.capabilities()).toEqual({
+      openCodexContext: false,
+      openFileInCodex: false,
+    });
 
     await result.connection.close();
   });
 });
+
+describe('Host native action contract', () => {
+  it('accepts only named actions with exact opaque targets', () => {
+    expect(
+      isNativeHostAction({
+        kind: 'open-file-in-codex',
+        targetId: 'native_0123456789abcdef0123456789abcdef',
+      }),
+    ).toBe(true);
+    expect(
+      isNativeHostAction({
+        kind: 'open-file-in-codex',
+        absolutePath: '/tmp/user-supplied.ts',
+      }),
+    ).toBe(false);
+    expect(
+      isNativeHostAction({
+        kind: 'run-host-command',
+        targetId: 'native_0123456789abcdef0123456789abcdef',
+      }),
+    ).toBe(false);
+  });
+});
diff --git a/tests/contract/protocol.contract.test.ts b/tests/contract/protocol.contract.test.ts
index e07f3e8..6285b19 100644
--- a/tests/contract/protocol.contract.test.ts
+++ b/tests/contract/protocol.contract.test.ts
@@ -117,6 +117,11 @@ describe('protocol runtime schemas', () => {
           head: { kind: 'initial' },
           indexTree: null,
           status: { kind: 'clean' },
+          provenance: {
+            kind: 'codex_task',
+            title: 'Implement exact navigation',
+            status: 'active',
+          },
           upstream: {
             kind: 'not-applicable',
             reason: 'The branch has no configured Upstream.',
@@ -136,7 +141,17 @@ describe('protocol runtime schemas', () => {
               ],
             },
           ],
-          nativeTargets: [],
+          nativeTargets: [
+            {
+              targetId: 'native_1123456789abcdef0123456789abcdef',
+              actions: [
+                'open_terminal',
+                'reveal_in_finder',
+                'copy_absolute_path',
+                'copy_branch_or_sha',
+              ],
+            },
+          ],
         },
       ],
       remotes: [
diff --git a/tests/e2e/codex-runtime.e2e.test.ts b/tests/e2e/codex-runtime.e2e.test.ts
index 16f58a9..e411d2b 100644
--- a/tests/e2e/codex-runtime.e2e.test.ts
+++ b/tests/e2e/codex-runtime.e2e.test.ts
@@ -1,3 +1,6 @@
+import { realpath, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import type {
@@ -5,15 +8,28 @@ import type {
   DedicatedCodexTarget,
   DedicatedRendererConnection,
 } from '@codex-git/host-adapter-codex-cdp';
-import type { HostContext } from '@codex-git/host-adapter';
+import type { HostContext, NativeHostAction } from '@codex-git/host-adapter';
 import { startCodexRuntime, type CodexRuntime } from '@codex-git/launcher';
+import {
+  PROTOCOL_VERSION_HEADER,
+  repositorySnapshotSchema,
+} from '@codex-git/protocol';
+
+import {
+  createTemporaryGitRepository,
+  type TemporaryGitRepository,
+} from '../fixtures/temporary-git-repository.js';
 
 const runtimes: CodexRuntime[] = [];
+const repositories: TemporaryGitRepository[] = [];
 
 afterEach(async () => {
   await Promise.all(
     runtimes.splice(0).map((runtime) => runtime.close().catch(() => undefined)),
   );
+  await Promise.all(
+    repositories.splice(0).map((repository) => repository.dispose()),
+  );
 });
 
 describe('Codex runtime composition', () => {
@@ -45,8 +61,122 @@ describe('Codex runtime composition', () => {
     await vi.waitFor(() => expect(instance.closed).toBe(true));
     expect(runtime.currentHost()).toBe('standalone');
   });
+
+  it('advertises and routes only an exact proven current Codex context', async () => {
+    const repository = await createTemporaryGitRepository();
+    repositories.push(repository);
+    await repository.git('config', 'user.name', 'Codex Git Tests');
+    await repository.git('config', 'user.email', 'codex-git@example.test');
+    await writeFile(join(repository.path, 'README.md'), 'fixture\n');
+    await repository.git('add', '--', 'README.md');
+    await repository.git('commit', '--quiet', '-m', 'Create fixture');
+    await writeFile(join(repository.path, 'README.md'), 'changed\n');
+    const canonicalCwd = await realpath(repository.path);
+    const renderer = new RoutableRenderer({
+      projectPath: canonicalCwd,
+      task: { id: 'task-15', title: 'Exact navigation' },
+      theme: 'dark',
+    });
+    const runtime = await startCodexRuntime({
+      connectRenderer: async () => renderer,
+      launchInstance: async () => new FixtureInstance(ownedTarget),
+      metadata: {
+        async read() {
+          return [
+            {
+              canonicalCwd,
+              kind: 'codex_task',
+              stable: true,
+              task: {
+                id: 'task-15',
+                status: 'active',
+                title: 'Exact navigation',
+              },
+            },
+          ];
+        },
+      },
+      projectPath: repository.path,
+      surfacePort: 0,
+    });
+    runtimes.push(runtime);
+    const snapshot = repositorySnapshotSchema.parse(
+      await (await protocolRequest(runtime, 'snapshot')).json(),
+    );
+    const target = snapshot.worktrees[0]?.nativeTargets.find(({ actions }) =>
+      actions.includes('open_codex_context'),
+    );
+    if (target === undefined) {
+      throw new Error('Expected a proven Codex context target.');
+    }
+
+    const response = await protocolRequest(runtime, 'native-actions', {
+      kind: 'open_codex_context',
+      targetId: target.targetId,
+    });
+
+    expect(await response.json()).toEqual({ kind: 'performed' });
+    expect(renderer.actions).toEqual([
+      { kind: 'open-codex-context', targetId: target.targetId },
+    ]);
+    expect(
+      snapshot.worktrees[0]?.changes.some(({ nativeTargets }) =>
+        nativeTargets.some(({ actions }) =>
+          actions.includes('open_file_in_codex'),
+        ),
+      ),
+    ).toBe(false);
+
+    renderer.setContext({
+      projectPath: '/private/tmp/another-project',
+      task: { id: 'task-other', title: 'Another task' },
+      theme: 'dark',
+    });
+    const staleContext = await protocolRequest(runtime, 'native-actions', {
+      kind: 'open_codex_context',
+      targetId: target.targetId,
+    });
+    expect(await staleContext.json()).toMatchObject({ kind: 'unavailable' });
+    expect(renderer.actions).toHaveLength(1);
+  });
 });
 
+class RoutableRenderer implements DedicatedRendererConnection {
+  readonly actions: NativeHostAction[] = [];
+  private listener: Parameters<DedicatedRendererConnection['subscribe']>[0] =
+    () => undefined;
+
+  constructor(private context: HostContext) {}
+
+  setContext(context: HostContext): void {
+    this.context = context;
+    this.listener({ kind: 'context', context });
+  }
+
+  currentContext(): HostContext {
+    return this.context;
+  }
+  isSurfaceOpen(): boolean {
+    return false;
+  }
+  projectIdentity(): { readonly id: string; readonly label: string } {
+    return { id: 'project-routable', label: 'codex-git' };
+  }
+  subscribe(listener: typeof this.listener): () => void {
+    this.listener = listener;
+    return () => {
+      this.listener = () => undefined;
+    };
+  }
+  async perform(action: NativeHostAction) {
+    this.actions.push(action);
+    return action.kind === 'open-codex-context'
+      ? ({ status: 'succeeded' } as const)
+      : ({ status: 'unsupported' } as const);
+  }
+  async close(): Promise<void> {}
+}
+
 const ownedTarget = {
   id: 'renderer-42',
   webSocketUrl: 'ws://127.0.0.1:43117/devtools/page/renderer-42',
@@ -109,3 +239,23 @@ class FailingRenderer implements DedicatedRendererConnection {
     throw new Error('Closed CDP socket cannot restore CSP');
   }
 }
+
+function protocolRequest(
+  runtime: CodexRuntime,
+  endpoint: 'native-actions' | 'snapshot',
+  body?: unknown,
+): Promise<Response> {
+  const url = new URL(
+    runtime.sessionUrl.pathname.replace(/\/session$/u, `/${endpoint}`),
+    runtime.sessionUrl,
+  );
+  return fetch(url, {
+    method: body === undefined ? 'GET' : 'POST',
+    headers: {
+      origin: runtime.surfaceUrl.origin,
+      [PROTOCOL_VERSION_HEADER]: '1',
+      ...(body === undefined ? {} : { 'content-type': 'application/json' }),
+    },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+}
diff --git a/tests/e2e/protocol-runtime.e2e.test.ts b/tests/e2e/protocol-runtime.e2e.test.ts
index d240e07..bbc4a4e 100644
--- a/tests/e2e/protocol-runtime.e2e.test.ts
+++ b/tests/e2e/protocol-runtime.e2e.test.ts
@@ -1,5 +1,12 @@
-import { mkdtemp, realpath, rm, symlink, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import {
+  mkdtemp,
+  realpath,
+  rm,
+  symlink,
+  unlink,
+  writeFile,
+} from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
 import { tmpdir } from 'node:os';
 
 import { afterEach, describe, expect, it } from 'vitest';
@@ -156,12 +163,91 @@ describe('protocol runtime composition', () => {
           freshness: { kind: 'current' },
           head: { kind: 'local_branch', displayName: branchName },
           status: { kind: 'clean' },
+          provenance: { kind: 'unclassified' },
           upstream: { kind: 'unpublished' },
         },
       ],
     });
   });
 
+  it('copies exact Worktree path and Branch from an opaque target', async () => {
+    const repository = await createRepositoryWithCommit();
+    const runtime = await startStandaloneRuntime({
+      projectPath: repository.path,
+      surfacePort: 0,
+    });
+    runtimes.push(runtime);
+    const snapshot = repositorySnapshotSchema.parse(
+      await (await protocolRequest(runtime, 'snapshot')).json(),
+    );
+    const worktree = snapshot.worktrees[0]!;
+    const target = worktree.nativeTargets[0]!;
+    const branchName = (
+      await repository.git('branch', '--show-current')
+    ).stdout.trim();
+
+    const [pathResponse, branchResponse] = await Promise.all([
+      protocolRequest(runtime, 'native-actions', {
+        kind: 'copy_absolute_path',
+        targetId: target.targetId,
+      }),
+      protocolRequest(runtime, 'native-actions', {
+        kind: 'copy_branch_or_sha',
+        targetId: target.targetId,
+      }),
+    ]);
+
+    expect(await pathResponse.json()).toEqual({
+      kind: 'copy_text',
+      text: await realpath(repository.path),
+    });
+    expect(await branchResponse.json()).toEqual({
+      kind: 'copy_text',
+      text: branchName,
+    });
+  });
+
+  it('rejects an opaque Worktree target after its generation disappears', async () => {
+    const repository = await createRepositoryWithCommit();
+    const linkedPath = join(
+      dirname(repository.path),
+      `${basename(repository.path)}-navigation-linked`,
+    );
+    temporaryDirectories.push(linkedPath);
+    await repository.git(
+      'worktree',
+      'add',
+      '--quiet',
+      '-b',
+      'navigation-linked',
+      linkedPath,
+    );
+    const runtime = await startStandaloneRuntime({
+      projectPath: repository.path,
+      surfacePort: 0,
+    });
+    runtimes.push(runtime);
+    const snapshot = repositorySnapshotSchema.parse(
+      await (await protocolRequest(runtime, 'snapshot')).json(),
+    );
+    const linked = snapshot.worktrees.find(({ role }) => role === 'linked');
+    if (linked?.nativeTargets[0] === undefined) {
+      throw new Error('Expected an exact Linked Worktree target.');
+    }
+    await repository.git('worktree', 'remove', '--force', linkedPath);
+
+    const response = await protocolRequest(runtime, 'native-actions', {
+      kind: 'copy_absolute_path',
+      targetId: linked.nativeTargets[0].targetId,
+    });
+
+    expect(await response.json()).toEqual({
+      kind: 'unavailable',
+      message:
+        'The exact target is no longer available. Refresh or use a safe copy action.',
+    });
+  });
+
   it('dispatches Fetch through command and operation endpoints', async () => {
     const repository = await createRepositoryWithCommit();
     const remotePath = await mkdtemp(join(tmpdir(), 'codex-git-remote-'));
@@ -379,7 +465,10 @@ describe('protocol runtime composition', () => {
       ({ displayPath }) => displayPath === 'outside-link',
     );
 
-    expect(deletion?.nativeTargets[0]?.actions).toEqual(['copy_relative_path']);
+    expect(deletion?.nativeTargets[0]?.actions).toEqual([
+      'copy_relative_path',
+      'copy_absolute_path',
+    ]);
     expect(link?.nativeTargets[0]?.actions).toContain('open_default_app');
     if (link?.nativeTargets[0] === undefined) {
       throw new Error('The symbolic-link target is absent.');
@@ -406,6 +495,56 @@ describe('protocol runtime composition', () => {
     expect(await actionResponse.json()).toMatchObject({ kind: 'unavailable' });
   });
 
+  it('targets the new path for renames and rejects a file that disappears before launch', async () => {
+    const repository = await createRepositoryWithCommit();
+    await writeFile(join(repository.path, 'old-name.txt'), 'rename me\n');
+    await writeFile(join(repository.path, 'disappearing.txt'), 'temporary\n');
+    await repository.git('add', '--', 'old-name.txt', 'disappearing.txt');
+    await repository.git('commit', '--quiet', '-m', 'Add navigation fixtures');
+    await repository.git('mv', 'old-name.txt', 'new-name.txt');
+    await writeFile(join(repository.path, 'disappearing.txt'), 'changed\n');
+    const runtime = await startStandaloneRuntime({
+      projectPath: repository.path,
+      surfacePort: 0,
+    });
+    runtimes.push(runtime);
+    const snapshot = repositorySnapshotSchema.parse(
+      await (await protocolRequest(runtime, 'snapshot')).json(),
+    );
+    const renamed = snapshot.worktrees[0]?.changes.find(
+      ({ previousDisplayPath }) => previousDisplayPath === 'old-name.txt',
+    );
+    const disappearing = snapshot.worktrees[0]?.changes.find(
+      ({ displayPath }) => displayPath === 'disappearing.txt',
+    );
+    if (renamed?.nativeTargets[0] === undefined) {
+      throw new Error('Expected a renamed Changed File target.');
+    }
+    expect(renamed.displayPath).toBe('new-name.txt');
+    const renameCopy = await protocolRequest(runtime, 'native-actions', {
+      kind: 'copy_relative_path',
+      targetId: renamed.nativeTargets[0].targetId,
+    });
+    expect(await renameCopy.json()).toEqual({
+      kind: 'copy_text',
+      text: 'new-name.txt',
+    });
+
+    if (disappearing?.nativeTargets[0] === undefined) {
+      throw new Error('Expected a disappearing Changed File target.');
+    }
+    await unlink(join(repository.path, 'disappearing.txt'));
+    const staleOpen = await protocolRequest(runtime, 'native-actions', {
+      kind: 'open_default_app',
+      targetId: disappearing.nativeTargets[0].targetId,
+    });
+    expect(await staleOpen.json()).toEqual({
+      kind: 'unavailable',
+      message:
+        'The exact target is no longer available. Refresh or use a safe copy action.',
+    });
+  });
+
   it('serves a typed non-Repository result for the Current Project', async () => {
     const projectPath = await mkdtemp(join(tmpdir(), 'codex-git-project-'));
     temporaryDirectories.push(projectPath);
@@ -505,7 +644,8 @@ describe('protocol runtime composition', () => {
 
 function protocolRequest(
   runtime: StandaloneRuntime,
-  endpoint: 'branches' | 'commands' | 'operations' | 'snapshot',
+  endpoint:
+    'branches' | 'commands' | 'native-actions' | 'operations' | 'snapshot',
   body?: unknown,
 ): Promise<Response> {
   const url = new URL(
diff --git a/tests/integration/worktree-provenance.integration.test.ts b/tests/integration/worktree-provenance.integration.test.ts
new file mode 100644
index 0000000..9a1917c
--- /dev/null
+++ b/tests/integration/worktree-provenance.integration.test.ts
@@ -0,0 +1,144 @@
+import { realpath, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import {
+  createRepositoryEngine,
+  type CodexMetadataAdapter,
+  type RepositorySession,
+} from '@codex-git/repository-engine';
+import type { AbsolutePath } from '@codex-git/protocol';
+
+import {
+  createTemporaryGitRepository,
+  type TemporaryGitRepository,
+} from '../fixtures/temporary-git-repository.js';
+
+const repositories: TemporaryGitRepository[] = [];
+
+afterEach(async () => {
+  await Promise.all(
+    repositories.splice(0).map((repository) => repository.dispose()),
+  );
+});
+
+describe('optional Codex Worktree provenance', () => {
+  it('joins stable Codex metadata only to its exact canonical cwd', async () => {
+    const repository = await createRepository();
+    const canonicalCwd = await realpath(repository.path);
+    const metadata: CodexMetadataAdapter = {
+      async read() {
+        return [
+          {
+            canonicalCwd,
+            kind: 'codex_task',
+            stable: true,
+            task: {
+              id: 'task-15',
+              status: 'active',
+              title: 'Add exact-target navigation',
+            },
+          },
+          {
+            canonicalCwd: `${canonicalCwd}-same-name`,
+            kind: 'external',
+            stable: true,
+          },
+        ];
+      },
+    };
+    const session = await createRepositoryEngine({ metadata }).open(
+      repository.path as AbsolutePath,
+    );
+
+    const worktree = await onlyWorktree(session);
+
+    expect(worktree.provenance).toEqual({
+      kind: 'codex_task',
+      task: {
+        id: 'task-15',
+        status: 'active',
+        title: 'Add exact-target navigation',
+      },
+    });
+  });
+
+  it('keeps every Git Worktree Unclassified when metadata is unavailable', async () => {
+    const repository = await createRepository();
+    const session = await createRepositoryEngine({
+      metadata: {
+        async read() {
+          throw new Error('Codex metadata is unavailable.');
+        },
+      },
+    }).open(repository.path as AbsolutePath);
+
+    const result = await session.snapshot();
+
+    expect(result.kind).toBe('repository');
+    if (result.kind !== 'repository') return;
+    expect(result.repository.worktrees).toHaveLength(1);
+    expect(result.repository.worktrees[0]?.provenance).toEqual({
+      kind: 'unclassified',
+    });
+  });
+
+  it('does not invalidate Git file targets when optional metadata disappears', async () => {
+    const repository = await createRepository();
+    await writeFile(join(repository.path, 'README.md'), 'changed\n');
+    const canonicalCwd = await realpath(repository.path);
+    let metadata = [
+      {
+        canonicalCwd,
+        kind: 'codex_task' as const,
+        stable: true,
+        task: {
+          id: 'task-optional',
+          status: 'active',
+          title: 'Optional metadata',
+        },
+      },
+    ];
+    const session = await createRepositoryEngine({
+      metadata: {
+        async read() {
+          return metadata;
+        },
+      },
+    }).open(repository.path as AbsolutePath);
+    const initial = await onlyWorktree(session);
+    metadata = [];
+
+    const withoutMetadata = await onlyWorktree(session);
+
+    expect(withoutMetadata.provenance).toEqual({ kind: 'unclassified' });
+    expect(withoutMetadata.worktreeRevision).toBe(initial.worktreeRevision + 1);
+    expect(withoutMetadata.changes[0]?.fileId).toBe(initial.changes[0]?.fileId);
+    expect(withoutMetadata.changes[0]?.nativeTargetId).toBe(
+      initial.changes[0]?.nativeTargetId,
+    );
+  });
+});
+
+async function createRepository(): Promise<TemporaryGitRepository> {
+  const repository = await createTemporaryGitRepository();
+  repositories.push(repository);
+  await repository.git('config', 'user.name', 'Codex Git Tests');
+  await repository.git('config', 'user.email', 'codex-git@example.test');
+  await writeFile(join(repository.path, 'README.md'), 'fixture\n');
+  await repository.git('add', '--', 'README.md');
+  await repository.git('commit', '--quiet', '-m', 'Create fixture');
+  return repository;
+}
+
+async function onlyWorktree(session: RepositorySession) {
+  const result = await session.snapshot();
+  if (
+    result.kind !== 'repository' ||
+    result.repository.worktrees[0] === undefined
+  ) {
+    throw new Error('Expected one Repository Worktree.');
+  }
+  return result.repository.worktrees[0];
+}