@@ -68,11 +68,18 @@ test('merges a graceful shutdown report and cleans runner leases with the start-
   const stateDir = mkdtempForTestSync('agent-device-daemon-command-');
   mocks.readDaemonStopIdentity.mockReturnValue({ pid: 123, processStartTime: 'start-time' });
   mocks.stopDaemon.mockResolvedValue(GRACEFUL_RESULT);
+  const claim = {
+    deviceKey: 'local:android:none:emulator-5554',
+    session: 'default',
+    platform: 'android',
+    deviceId: 'emulator-5554',
+  };
   mocks.readDaemonShutdownReport.mockReturnValue({
     providerReleases: {
       released: [{ leaseId: 'lease-1', provider: 'limrun' }],
       pending: [],
     },
+    claims: { released: [claim], orphaned: [] },
   });
 
   try {
@@ -95,6 +102,9 @@ test('merges a graceful shutdown report and cleans runner leases with the start-
           released: [{ leaseId: 'lease-1', provider: 'limrun' }],
           pending: [],
         },
+        // #1799: a graceful stop reports the claims it actually released.
+        claimsReleased: [claim],
+        claimsOrphaned: [],
       }),
       expect.any(Function),
     );
 
@@ -41,7 +41,12 @@ function mergeShutdownReport(
 ): DaemonStopResult {
   if (stopped.mode !== 'graceful' || report) {
     return report
-      ? { ...stopped, providerReleases: { status: 'completed', ...report.providerReleases } }
+      ? {
+          ...stopped,
+          providerReleases: { status: 'completed', ...report.providerReleases },
+          claimsReleased: report.claims.released,
+          claimsOrphaned: report.claims.orphaned,
+        }
       : stopped;
   }
   return {
 
@@ -9,7 +9,14 @@ import {
 import { LeaseRegistry } from '../lease-registry.ts';
 import { mkdtempForTestSync } from '../../__tests__/test-utils/tmp-dir.ts';
 
-test('round-trips provider release records without persisting lease credentials', () => {
+const claim = {
+  deviceKey: 'local:android:none:emulator-5554',
+  session: 'default',
+  platform: 'android',
+  deviceId: 'emulator-5554',
+};
+
+test('round-trips provider release and device claim records without lease credentials', () => {
   const stateDir = mkdtempForTestSync('agent-device-shutdown-report-');
   const lease = new LeaseRegistry().allocateLease({
     tenantId: 'tenant-a',
@@ -18,13 +25,36 @@ test('round-trips provider release records without persisting lease credentials'
   });
 
   try {
-    writeDaemonShutdownReport(stateDir, { released: [lease], pending: [lease] });
+    writeDaemonShutdownReport(stateDir, {
+      providerReleases: { released: [lease], pending: [lease] },
+      claims: { released: [claim], orphaned: [] },
+    });
 
     expect(readDaemonShutdownReport(stateDir)).toEqual({
       providerReleases: {
         released: [{ leaseId: lease.leaseId, provider: 'limrun' }],
         pending: [{ leaseId: lease.leaseId, provider: 'limrun' }],
       },
+      claims: { released: [claim], orphaned: [] },
+    });
+  } finally {
+    fs.rmSync(stateDir, { recursive: true, force: true });
+  }
+});
+
+test('a report written before claim reporting still reads its provider releases', () => {
+  const stateDir = mkdtempForTestSync('agent-device-shutdown-report-');
+  const reportPath = path.join(stateDir, 'daemon-shutdown.json');
+
+  try {
+    fs.writeFileSync(
+      reportPath,
+      JSON.stringify({ providerReleases: { released: [], pending: [] } }),
+    );
+
+    expect(readDaemonShutdownReport(stateDir)).toEqual({
+      providerReleases: { released: [], pending: [] },
+      claims: { released: [], orphaned: [] },
     });
   } finally {
     fs.rmSync(stateDir, { recursive: true, force: true });
 
@@ -9,21 +9,45 @@ export type ProviderReleaseRecord = {
   provider?: string;
 };
 
+/**
+ * #1320: what happened to one session's device claim during graceful teardown.
+ * `released` means the claim was cleared after the session reached a safe
+ * terminal state; `orphaned` means teardown left it in place, so the exiting
+ * daemon's dead owner identity is what later proves it reclaimable.
+ */
+export type DeviceClaimRecord = {
+  deviceKey: string;
+  session: string;
+  platform: string;
+  deviceId: string;
+};
+
 export type DaemonShutdownReport = {
   providerReleases: {
     released: ProviderReleaseRecord[];
     pending: ProviderReleaseRecord[];
   };
+  claims: {
+    released: DeviceClaimRecord[];
+    orphaned: DeviceClaimRecord[];
+  };
 };
 
 export function writeDaemonShutdownReport(
   stateDir: string,
-  providerReleases: { released: readonly DeviceLease[]; pending: readonly DeviceLease[] },
+  outcome: {
+    providerReleases: { released: readonly DeviceLease[]; pending: readonly DeviceLease[] };
+    claims: { released: readonly DeviceClaimRecord[]; orphaned: readonly DeviceClaimRecord[] };
+  },
 ): void {
   const report: DaemonShutdownReport = {
     providerReleases: {
-      released: providerReleases.released.map(toProviderReleaseRecord),
-      pending: providerReleases.pending.map(toProviderReleaseRecord),
+      released: outcome.providerReleases.released.map(toProviderReleaseRecord),
+      pending: outcome.providerReleases.pending.map(toProviderReleaseRecord),
+    },
+    claims: {
+      released: [...outcome.claims.released],
+      orphaned: [...outcome.claims.orphaned],
     },
   };
   const filePath = shutdownReportPath(stateDir);
@@ -42,7 +66,10 @@ export function writeDaemonShutdownReport(
 export function readDaemonShutdownReport(stateDir: string): DaemonShutdownReport | null {
   try {
     const parsed = JSON.parse(fs.readFileSync(shutdownReportPath(stateDir), 'utf8')) as unknown;
-    return isDaemonShutdownReport(parsed) ? parsed : null;
+    if (!isProviderReleaseReport(parsed)) return null;
+    // A report left behind by a daemon that predates claim reporting still
+    // describes its provider releases honestly; it just knows nothing of claims.
+    return { ...parsed, claims: readClaimSection(parsed) };
   } catch {
     return null;
   }
@@ -65,7 +92,9 @@ function toProviderReleaseRecord(lease: DeviceLease): ProviderReleaseRecord {
   };
 }
 
-function isDaemonShutdownReport(value: unknown): value is DaemonShutdownReport {
+function isProviderReleaseReport(
+  value: unknown,
+): value is Omit<DaemonShutdownReport, 'claims'> & { claims?: unknown } {
   if (!value || typeof value !== 'object') return false;
   const releases = (value as { providerReleases?: unknown }).providerReleases;
   if (!releases || typeof releases !== 'object') return false;
@@ -78,6 +107,31 @@ function isDaemonShutdownReport(value: unknown): value is DaemonShutdownReport {
   );
 }
 
+function readClaimSection(value: { claims?: unknown }): DaemonShutdownReport['claims'] {
+  const claims = value.claims;
+  if (!claims || typeof claims !== 'object') return { released: [], orphaned: [] };
+  const records = claims as { released?: unknown; orphaned?: unknown };
+  return {
+    released: readClaimRecords(records.released),
+    orphaned: readClaimRecords(records.orphaned),
+  };
+}
+
+function readClaimRecords(value: unknown): DeviceClaimRecord[] {
+  return Array.isArray(value) ? value.filter(isDeviceClaimRecord) : [];
+}
+
+function isDeviceClaimRecord(value: unknown): value is DeviceClaimRecord {
+  if (!value || typeof value !== 'object') return false;
+  const record = value as Partial<Record<keyof DeviceClaimRecord, unknown>>;
+  return (
+    typeof record.deviceKey === 'string' &&
+    typeof record.session === 'string' &&
+    typeof record.platform === 'string' &&
+    typeof record.deviceId === 'string'
+  );
+}
+
 function isProviderReleaseRecord(value: unknown): value is ProviderReleaseRecord {
   if (!value || typeof value !== 'object') return false;
   const record = value as { leaseId?: unknown; provider?: unknown };
 
@@ -4,7 +4,7 @@ import { isAgentDeviceDaemonProcess, trySignalProcess } from './daemon-process.t
 import { isProcessAlive, waitForProcessExit } from '../utils/host-process.ts';
 import { sleep } from '../utils/timeouts.ts';
 import type { DaemonPaths } from './config.ts';
-import type { ProviderReleaseRecord } from './daemon-shutdown-report.ts';
+import type { DeviceClaimRecord, ProviderReleaseRecord } from './daemon-shutdown-report.ts';
 
 const DAEMON_STOP_GRACE_TIMEOUT_MS = 10_000;
 const DAEMON_STOP_KILL_TIMEOUT_MS = 2_000;
@@ -19,8 +19,13 @@ export type DaemonStopResult = {
   stopped: boolean;
   mode: 'graceful' | 'forced' | 'not-running';
   cleanupConfidence: 'known' | 'unknown';
-  claimsReleased: [];
-  claimsOrphaned: [];
+  /**
+   * #1320 claim results. Only a graceful stop can carry values: they come from
+   * the shutdown report the exiting daemon wrote, so a forced kill or a daemon
+   * that was not running reports none rather than claiming certainty.
+   */
+  claimsReleased: DeviceClaimRecord[];
+  claimsOrphaned: DeviceClaimRecord[];
   providerReleases: {
     status: 'completed' | 'unknown';
     released: ProviderReleaseRecord[];
 
@@ -24,12 +24,9 @@ import { closeDaemonServers } from './server-shutdown.ts';
 import type { DaemonInvokeFn, SessionState } from '../types.ts';
 import { createDaemonIdleReap } from './daemon-idle-reap.ts';
 import { finalizeDaemonSessionLease } from './daemon-session-lease-finalizer.ts';
-import {
-  clearDeviceClaim,
-  reconcileOrphanedDeviceClaims,
-  type DeviceClaimReconciler,
-} from '../device-claims.ts';
+import { reconcileOrphanedDeviceClaims, type DeviceClaimReconciler } from '../device-claims.ts';
 import { createDeviceClaimReconciler } from '../device-claim-reconciliation.ts';
+import { createDaemonShutdownClaimLedger } from './daemon-shutdown-claims.ts';
 import {
   emitDiagnostic,
   flushDiagnosticsToSessionFile,
@@ -323,30 +320,36 @@ export async function startDaemonRuntime(
     );
   };
 
-  const teardownDaemonSession = async (session: SessionState): Promise<void> =>
-    await teardownDaemonSessionForShutdown({
-      session,
-      sessionStore,
-      stderr,
-      finalizeApplicationLifecycle: async (sessionToFinalize) =>
-        await finalizeDaemonSessionApplicationLifecycle({
-          gateway: deviceRuntimeGateway,
-          scope: createDaemonRecoveryPlatformScope(),
-          session: sessionToFinalize,
-          stateDir: baseDir,
-          runtimeHints: runtimeHintValues(sessionStore.getRuntimeHints(sessionToFinalize.name)),
-        }),
-      beforeDelete: async (sessionToFinalize) => {
-        await finalizeDaemonSessionLease({
-          session: sessionToFinalize,
-          leaseRegistry,
-          expiredProviderLeaseReleaser,
-          timeoutMs: DAEMON_SESSION_LEASE_RELEASE_TIMEOUT_MS,
-        });
-      },
-      afterSuccessfulTeardown: async (sessionToFinalize) =>
-        await clearDeviceClaim(sessionToFinalize.deviceClaim),
-    });
+  const shutdownClaimLedger = createDaemonShutdownClaimLedger();
+
+  const teardownDaemonSession = async (session: SessionState): Promise<void> => {
+    try {
+      await teardownDaemonSessionForShutdown({
+        session,
+        sessionStore,
+        stderr,
+        finalizeApplicationLifecycle: async (sessionToFinalize) =>
+          await finalizeDaemonSessionApplicationLifecycle({
+            gateway: deviceRuntimeGateway,
+            scope: createDaemonRecoveryPlatformScope(),
+            session: sessionToFinalize,
+            stateDir: baseDir,
+            runtimeHints: runtimeHintValues(sessionStore.getRuntimeHints(sessionToFinalize.name)),
+          }),
+        beforeDelete: async (sessionToFinalize) => {
+          await finalizeDaemonSessionLease({
+            session: sessionToFinalize,
+            leaseRegistry,
+            expiredProviderLeaseReleaser,
+            timeoutMs: DAEMON_SESSION_LEASE_RELEASE_TIMEOUT_MS,
+          });
+        },
+        afterSuccessfulTeardown: shutdownClaimLedger.releaseClaim,
+      });
+    } finally {
+      shutdownClaimLedger.finalize(session);
+    }
+  };
 
   const teardownDaemonSessions = async (): Promise<void> => {
     const sessionsToStop = sessionStore.toArray();
@@ -545,13 +548,18 @@ export async function startDaemonRuntime(
     const providerReleaseDrain = await expiredProviderLeaseReleaser.drain(
       DAEMON_PROVIDER_RELEASE_DRAIN_TIMEOUT_MS,
     );
-    writeDaemonShutdownReport(baseDir, providerReleaseDrain);
+    writeDaemonShutdownReport(baseDir, {
+      providerReleases: providerReleaseDrain,
+      claims: shutdownClaimLedger.claims,
+    });
     emitDiagnostic({
       level: providerReleaseDrain.pending.length === 0 ? 'info' : 'warn',
       phase: 'daemon_shutdown_provider_release_drain',
       data: {
         releasedLeaseIds: providerReleaseDrain.released.map((lease) => lease.leaseId),
         pendingLeaseIds: providerReleaseDrain.pending.map((lease) => lease.leaseId),
+        releasedDeviceKeys: shutdownClaimLedger.claims.released.map((claim) => claim.deviceKey),
+        orphanedDeviceKeys: shutdownClaimLedger.claims.orphaned.map((claim) => claim.deviceKey),
       },
     });
     expiredProviderLeaseReleaser.shutdown();